autoremediator 0.19.0 → 0.20.0

package/dist/index.js

@@ -827,6 +827,8 @@ function toSarifOutput(report) {
 }
 
 // src/api/vex/index.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
 import { randomUUID } from "crypto";
 function mapReportToVulnerability(report) {
   const hasResolved = report.results.some((r) => r.applied && !r.unresolvedReason);
@@ -904,22 +906,22 @@ function toCycloneDxVex(report, options = {}) {
 }
 
 // src/api/patches/inspection.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir, readFile as readFile2, stat } from "fs/promises";
 import { join as join5 } from "path";
 
 // src/remediation/strategies/patch-utils.ts
-import { existsSync as existsSync3, mkdirSync, writeFileSync, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync4 } from "fs";
 import { join as join4 } from "path";
 import { execa as execa2 } from "execa";
 
 // src/platform/package-manager/index.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
 import { execa } from "execa";
 
 // src/platform/package-manager/list-parser.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { join } from "path";
 function parsePackageManagerListOutput(pm, stdout) {
   const versions = /* @__PURE__ */ new Map();
@@ -992,7 +994,7 @@ function resolveDenoInventory(cwd) {
   const versions = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = readFileSync(join(cwd, "deno.lock"), "utf8");
+    raw = readFileSync2(join(cwd, "deno.lock"), "utf8");
   } catch {
     return versions;
   }
@@ -1032,7 +1034,7 @@ function extractNameVersion(spec, versions) {
 }
 
 // src/platform/package-manager/driver.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 
 // src/platform/package-manager/index.ts
@@ -1046,10 +1048,10 @@ async function getYarnMajorVersion(cwd) {
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync2(join3(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join3(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync2(join3(cwd, "bun.lockb")) || existsSync2(join3(cwd, "bun.lock"))) return "bun";
-  if (existsSync2(join3(cwd, "deno.lock"))) return "deno";
+  if (existsSync3(join3(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join3(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync3(join3(cwd, "bun.lockb")) || existsSync3(join3(cwd, "bun.lock"))) return "bun";
+  if (existsSync3(join3(cwd, "deno.lock"))) return "deno";
   return "npm";
 }
 function withWorkspace(command, pm, workspace) {
@@ -1110,10 +1112,10 @@ function resolveTestCommand(pm, constraints) {
 function resolveTypecheckCommand(pm, constraints, cwd = process.cwd()) {
   const pkgJsonPath = join3(cwd, "package.json");
   let hasTypecheckScript = false;
-  const hasTsConfig = existsSync2(join3(cwd, "tsconfig.json"));
-  if (existsSync2(pkgJsonPath)) {
+  const hasTsConfig = existsSync3(join3(cwd, "tsconfig.json"));
+  if (existsSync3(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf8"));
       if (pkg.scripts?.typecheck) {
         hasTypecheckScript = true;
       }
@@ -1248,7 +1250,7 @@ function validatePatchDiff(patchContent) {
 }
 
 // src/api/patches/helpers.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readFile } from "fs/promises";
 import { isAbsolute, resolve, sep } from "path";
 var DEFAULT_PATCHES_DIR = "./patches";
@@ -1267,7 +1269,7 @@ function resolveArtifactPath(cwd, patchFilePath) {
   return resolved;
 }
 async function readManifest(manifestFilePath) {
-  if (!existsSync4(manifestFilePath)) {
+  if (!existsSync5(manifestFilePath)) {
     return void 0;
   }
   try {
@@ -1312,7 +1314,7 @@ function toSummary(inspection) {
 async function listPatchArtifacts(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const patchesDirPath = resolvePatchesDir(cwd, options.patchesDir);
-  if (!existsSync5(patchesDirPath)) {
+  if (!existsSync6(patchesDirPath)) {
     return [];
   }
   const entries = await readdir(patchesDirPath, { withFileTypes: true });
@@ -1330,10 +1332,10 @@ async function inspectPatchArtifact(patchFilePath, options = {}) {
   const resolvedPatchPath = resolveArtifactPath(cwd, patchFilePath);
   const patchFileName = resolvedPatchPath.split("/").pop() ?? resolvedPatchPath;
   const manifestFilePath = `${resolvedPatchPath}.json`;
-  if (!existsSync5(resolvedPatchPath)) {
+  if (!existsSync6(resolvedPatchPath)) {
     return {
       patchFilePath: resolvedPatchPath,
-      manifestFilePath: existsSync5(manifestFilePath) ? manifestFilePath : void 0,
+      manifestFilePath: existsSync6(manifestFilePath) ? manifestFilePath : void 0,
       patchFileName,
       exists: false,
       diffValid: false,
@@ -1377,14 +1379,14 @@ function defineTool(config) {
 
 // src/remediation/tools/check-inventory.ts
 import { z } from "zod";
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { join as join8 } from "path";
 import { execa as execa3 } from "execa";
 
 // src/platform/policy.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
-import { parse as yamlParse } from "yaml";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 var DEFAULT_POLICY = {
   allowMajorBumps: false,
   denyPackages: [],
@@ -1414,14 +1416,28 @@ var DEFAULT_POLICY = {
   escalationGraph: void 0
 };
 function loadPolicy(cwd, explicitPath) {
-  const candidate = explicitPath ?? join6(cwd, ".github", "autoremediator.yml");
-  if (!existsSync6(candidate)) return DEFAULT_POLICY;
+  let content;
+  if (explicitPath && (explicitPath.trim().startsWith("{") || explicitPath.trim().startsWith("---"))) {
+    content = explicitPath;
+  } else {
+    const candidate = explicitPath ?? join6(cwd, ".github", "autoremediator.yml");
+    if (!existsSync7(candidate)) return DEFAULT_POLICY;
+    try {
+      content = readFileSync5(candidate, "utf8");
+    } catch {
+      return DEFAULT_POLICY;
+    }
+  }
   try {
-    const parsed = yamlParse(readFileSync4(candidate, "utf8"));
+    const parsed = yamlParse(content);
     return {
       allowMajorBumps: parsed.allowMajorBumps ?? DEFAULT_POLICY.allowMajorBumps,
-      denyPackages: parsed.denyPackages ?? DEFAULT_POLICY.denyPackages,
-      allowPackages: parsed.allowPackages ?? DEFAULT_POLICY.allowPackages,
+      denyPackages: Array.isArray(parsed.denyPackages) ? parsed.denyPackages.filter(
+        (p) => typeof p === "string" && p.trim().length > 0
+      ) : DEFAULT_POLICY.denyPackages,
+      allowPackages: Array.isArray(parsed.allowPackages) ? parsed.allowPackages.filter(
+        (p) => typeof p === "string" && p.trim().length > 0
+      ) : DEFAULT_POLICY.allowPackages,
       constraints: {
         directDependenciesOnly: parsed.constraints?.directDependenciesOnly ?? DEFAULT_POLICY.constraints?.directDependenciesOnly ?? false,
         preferVersionBump: parsed.constraints?.preferVersionBump ?? DEFAULT_POLICY.constraints?.preferVersionBump ?? false,
@@ -1465,20 +1481,49 @@ function loadPolicy(cwd, explicitPath) {
     return DEFAULT_POLICY;
   }
 }
+function isPackageInList(list, packageName) {
+  if (!list || !Array.isArray(list) || typeof packageName !== "string" || !packageName.trim()) {
+    return false;
+  }
+  const target = packageName.trim();
+  return list.some((pattern) => {
+    if (typeof pattern !== "string") return false;
+    const cleanPattern = pattern.trim();
+    if (!cleanPattern) return false;
+    if (cleanPattern === target) return true;
+    if (cleanPattern === "*") return true;
+    if (cleanPattern.endsWith("/*")) {
+      const prefix = cleanPattern.slice(0, -1);
+      return target.startsWith(prefix);
+    }
+    if (cleanPattern.endsWith("*")) {
+      const prefix = cleanPattern.slice(0, -1);
+      return target.startsWith(prefix);
+    }
+    return false;
+  });
+}
 function isPackageAllowed(policy, packageName) {
-  if (policy.denyPackages.includes(packageName)) return false;
-  if (policy.allowPackages.length > 0 && !policy.allowPackages.includes(packageName)) {
+  if (!policy || typeof policy !== "object" || typeof packageName !== "string") {
+    return true;
+  }
+  if (isPackageInList(policy.denyPackages, packageName)) return false;
+  const allowList = Array.isArray(policy.allowPackages) ? policy.allowPackages.filter((p) => typeof p === "string" && p.trim().length > 0) : [];
+  if (allowList.length > 0 && !isPackageInList(allowList, packageName)) {
     return false;
   }
   return true;
 }
 function isActiveSuppression(suppression) {
+  if (!suppression || typeof suppression !== "object") return false;
   if (!suppression.expiresAt) return true;
-  return new Date(suppression.expiresAt) > /* @__PURE__ */ new Date();
+  const expires = new Date(suppression.expiresAt).getTime();
+  if (isNaN(expires)) return true;
+  return expires > Date.now();
 }
 function loadSuppressionsFile(filePath) {
   try {
-    const content = readFileSync4(filePath, "utf8");
+    const content = readFileSync5(filePath, "utf8");
     const parsed = yamlParse(content);
     return Array.isArray(parsed?.suppressions) ? parsed.suppressions : [];
   } catch {
@@ -1486,6 +1531,9 @@ function loadSuppressionsFile(filePath) {
   }
 }
 function checkSlaBreach(cveId, severity, publishedAt, slaPolicy) {
+  if (typeof severity !== "string" || !slaPolicy || typeof slaPolicy !== "object") {
+    return null;
+  }
   const severityKey = severity.toLowerCase();
   const deadlineHours = slaPolicy[severityKey];
   if (typeof deadlineHours !== "number") return null;
@@ -1504,18 +1552,21 @@ function checkSlaBreach(cveId, severity, publishedAt, slaPolicy) {
   };
 }
 
+// src/remediation/tools/check-inventory.ts
+import semver from "semver";
+
 // src/platform/workspace.ts
-import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync5, statSync } from "fs";
+import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync6, statSync } from "fs";
 import { join as join7, resolve as resolve2, relative } from "path";
 import yaml from "yaml";
 function findWorkspaceRoot(startDir) {
   let curr = resolve2(startDir);
   while (true) {
-    if (existsSync7(join7(curr, "pnpm-workspace.yaml"))) return curr;
+    if (existsSync8(join7(curr, "pnpm-workspace.yaml"))) return curr;
     const pkgPath = join7(curr, "package.json");
-    if (existsSync7(pkgPath)) {
+    if (existsSync8(pkgPath)) {
       try {
-        const parsed = JSON.parse(readFileSync5(pkgPath, "utf8"));
+        const parsed = JSON.parse(readFileSync6(pkgPath, "utf8"));
         if (parsed.workspaces) return curr;
       } catch {
       }
@@ -1531,9 +1582,9 @@ function findWorkspacePackages(cwd) {
   const packages = [];
   const packageGlobs = [];
   const pnpmWorkspaceFile = join7(rootCwd, "pnpm-workspace.yaml");
-  if (existsSync7(pnpmWorkspaceFile)) {
+  if (existsSync8(pnpmWorkspaceFile)) {
     try {
-      const content = readFileSync5(pnpmWorkspaceFile, "utf8");
+      const content = readFileSync6(pnpmWorkspaceFile, "utf8");
       const parsed = yaml.parse(content);
       if (Array.isArray(parsed?.packages)) {
         packageGlobs.push(...parsed.packages);
@@ -1542,9 +1593,9 @@ function findWorkspacePackages(cwd) {
     }
   }
   const rootPkgFile = join7(rootCwd, "package.json");
-  if (existsSync7(rootPkgFile)) {
+  if (existsSync8(rootPkgFile)) {
     try {
-      const rootPkg = JSON.parse(readFileSync5(rootPkgFile, "utf8"));
+      const rootPkg = JSON.parse(readFileSync6(rootPkgFile, "utf8"));
       if (Array.isArray(rootPkg.workspaces)) {
         packageGlobs.push(...rootPkg.workspaces);
       } else if (Array.isArray(rootPkg.workspaces?.packages)) {
@@ -1554,9 +1605,9 @@ function findWorkspacePackages(cwd) {
     }
   }
   const denoJsonFile = join7(rootCwd, "deno.json");
-  if (existsSync7(denoJsonFile)) {
+  if (existsSync8(denoJsonFile)) {
     try {
-      const denoJson = JSON.parse(readFileSync5(denoJsonFile, "utf8"));
+      const denoJson = JSON.parse(readFileSync6(denoJsonFile, "utf8"));
       if (Array.isArray(denoJson.workspace)) {
         packageGlobs.push(...denoJson.workspace);
       }
@@ -1572,7 +1623,7 @@ function findWorkspacePackages(cwd) {
     if (!cleanGlob || cleanGlob.startsWith("!")) continue;
     if (cleanGlob.endsWith("/*")) {
       const parentDir = join7(rootCwd, cleanGlob.slice(0, -2));
-      if (!existsSync7(parentDir)) continue;
+      if (!existsSync8(parentDir)) continue;
       try {
         const entries = readdirSync(parentDir);
         for (const entry of entries) {
@@ -1589,7 +1640,7 @@ function findWorkspacePackages(cwd) {
       }
     } else {
       const directDir = join7(rootCwd, cleanGlob);
-      if (existsSync7(directDir)) {
+      if (existsSync8(directDir)) {
         try {
           if (statSync(directDir).isDirectory()) {
             addWorkspacePackage(rootCwd, directDir, packages, seenDirs);
@@ -1606,9 +1657,9 @@ function addWorkspacePackage(rootCwd, dir, out, seen) {
   if (seen.has(norm)) return;
   seen.add(norm);
   const manifestPath = join7(dir, "package.json");
-  if (!existsSync7(manifestPath)) return;
+  if (!existsSync8(manifestPath)) return;
   try {
-    const content = readFileSync5(manifestPath, "utf8");
+    const content = readFileSync6(manifestPath, "utf8");
     const manifest = JSON.parse(content);
     out.push({
       name: manifest.name ?? relative(rootCwd, dir),
@@ -1639,6 +1690,37 @@ function findDeclaringWorkspacePackage(cwd, dependencyName, filterWorkspace) {
 }
 
 // src/remediation/tools/check-inventory.ts
+function resolveInventoryVersion(rawVersion) {
+  const trimmed = rawVersion.trim();
+  if (semver.valid(trimmed)) {
+    return semver.clean(trimmed) ?? trimmed;
+  }
+  let spec = trimmed;
+  if (spec.startsWith("npm:") && spec.includes("@")) {
+    spec = spec.slice(spec.lastIndexOf("@") + 1);
+  }
+  if (spec.startsWith("workspace:")) {
+    spec = spec.slice("workspace:".length).trim();
+  }
+  if (semver.valid(spec)) {
+    return semver.clean(spec) ?? spec;
+  }
+  try {
+    const min = semver.minVersion(spec);
+    if (min?.version && semver.valid(min.version)) {
+      return min.version;
+    }
+  } catch {
+  }
+  try {
+    const coerced = semver.coerce(spec);
+    if (coerced?.version && semver.valid(coerced.version)) {
+      return coerced.version;
+    }
+  } catch {
+  }
+  return semver.clean(trimmed) ?? trimmed;
+}
 var checkInventoryTool = defineTool({
   description: "Read the project's package.json and installed dependencies to list packages and exact versions. Must be called before checking version matches.",
   parameters: z.object({
@@ -1655,7 +1737,7 @@ var checkInventoryTool = defineTool({
   }) => {
     let pkgJson;
     try {
-      pkgJson = JSON.parse(readFileSync6(join8(cwd, "package.json"), "utf8"));
+      pkgJson = JSON.parse(readFileSync7(join8(cwd, "package.json"), "utf8"));
     } catch {
       return {
         packages: [],
@@ -1698,11 +1780,12 @@ var checkInventoryTool = defineTool({
     if (packages.length === 0) {
       const allDeps = {
         ...pkgJson.dependencies,
-        ...pkgJson.devDependencies
+        ...pkgJson.devDependencies,
+        ...pkgJson.peerDependencies
       };
-      for (const [name, version] of Object.entries(allDeps)) {
-        const cleaned = version.replace(/^[\^~>=<]+/, "").trim();
-        packages.push({ name, version: cleaned, type: "direct" });
+      for (const [name, rawVersion] of Object.entries(allDeps)) {
+        const version = resolveInventoryVersion(rawVersion);
+        packages.push({ name, version, type: "direct" });
       }
     }
     return { packages };
@@ -1812,13 +1895,12 @@ async function validatePatchArtifact(patchFilePath, options = {}) {
 }
 
 // src/api/patches/reconcile.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { readFile as readFile3, rm, writeFile } from "fs/promises";
 import { join as join10 } from "path";
-import { execa as execa5 } from "execa";
 
 // src/remediation/evaluate-package.ts
-import semver2 from "semver";
+import semver3 from "semver";
 
 // src/platform/http-client.ts
 var DEFAULT_TIMEOUT_MS = 1e4;
@@ -2179,10 +2261,10 @@ async function enrichWithCisaKev(details) {
 }
 
 // src/intelligence/sources/registry.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { join as join9 } from "path";
 import { execa as execa4 } from "execa";
-import semver from "semver";
+import semver2 from "semver";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 async function fetchPackageVersions(packageName) {
   const url = `${NPM_REGISTRY}/${encodeURIComponent(packageName)}`;
@@ -2218,15 +2300,15 @@ async function resolveSafeUpgradeVersion(packageName, installedVersion, firstPat
       majorOnlyFixAvailable: false
     };
   }
-  const installed = semver.parse(installedVersion);
-  const candidates = versions.filter((v) => semver.valid(v) && semver.gte(v, firstPatchedVersion)).filter((v) => {
+  const installed = semver2.parse(installedVersion);
+  const candidates = versions.filter((v) => semver2.valid(v) && semver2.gte(v, firstPatchedVersion)).filter((v) => {
     if (!vulnerableRange) return true;
     try {
-      return !semver.satisfies(v, vulnerableRange, { includePrerelease: false });
+      return !semver2.satisfies(v, vulnerableRange, { includePrerelease: false });
     } catch {
       return true;
     }
-  }).sort(semver.compare);
+  }).sort(semver2.compare);
   if (!candidates.length) {
     return {
       candidates: {},
@@ -2266,13 +2348,14 @@ async function resolveSafeUpgradeVersion(packageName, installedVersion, firstPat
   };
 }
 function classifyUpgradeLevel(installedVersion, candidateVersion) {
-  const installed = semver.parse(installedVersion);
-  const candidate = semver.parse(candidateVersion);
+  const installed = semver2.parse(installedVersion) ?? semver2.coerce(installedVersion);
+  const candidate = semver2.parse(candidateVersion) ?? semver2.coerce(candidateVersion);
   if (!installed || !candidate) return void 0;
+  if (!semver2.gte(candidate.version, installed.version)) return void 0;
   if (candidate.major > installed.major) return "major";
-  if (candidate.minor > installed.minor) return "minor";
-  if (candidate.patch > installed.patch || candidate.version === installed.version) {
-    return "patch";
+  if (candidate.major === installed.major && candidate.minor > installed.minor) return "minor";
+  if (candidate.major === installed.major && candidate.minor === installed.minor) {
+    if (candidate.patch >= installed.patch) return "patch";
   }
   return void 0;
 }
@@ -2356,7 +2439,7 @@ async function queryOutdatedPackages(cwd, options = {}) {
   }
   let directDeps;
   try {
-    const pkgRaw = JSON.parse(readFileSync7(join9(cwd, "package.json"), "utf8"));
+    const pkgRaw = JSON.parse(readFileSync8(join9(cwd, "package.json"), "utf8"));
     directDeps = /* @__PURE__ */ new Set([
       ...Object.keys(pkgRaw.dependencies ?? {}),
       ...Object.keys(pkgRaw.devDependencies ?? {})
@@ -2372,7 +2455,7 @@ async function queryOutdatedPackages(cwd, options = {}) {
     if (!currentVersion || !latestVersion) continue;
     const dependencyScope = directDeps.has(name) ? "direct" : "transitive";
     if (!options.includeTransitive && dependencyScope === "transitive") continue;
-    const isMajorBump = semver.valid(currentVersion) !== null && semver.valid(latestVersion) !== null && semver.major(latestVersion) > semver.major(currentVersion);
+    const isMajorBump = semver2.valid(currentVersion) !== null && semver2.valid(latestVersion) !== null && semver2.major(latestVersion) > semver2.major(currentVersion);
     result.set(name, {
       currentVersion,
       wantedVersion,
@@ -2393,7 +2476,7 @@ async function evaluatePackage(packageName, options = {}) {
   try {
     versions = await fetchPackageVersions(packageName);
     if (versions.length > 0) {
-      const valid = versions.filter((v) => semver2.valid(v)).sort((a, b) => semver2.compare(a, b));
+      const valid = versions.filter((v) => semver3.valid(v)).sort((a, b) => semver3.compare(a, b));
       latestVersion = valid[valid.length - 1];
     }
   } catch {
@@ -2419,8 +2502,8 @@ async function evaluatePackage(packageName, options = {}) {
       (p) => p.name.toLowerCase() === packageName.toLowerCase()
     );
     if (version && affected?.vulnerableRange) {
-      const cleanVer = semver2.clean(version) || version;
-      if (semver2.valid(cleanVer) && !semver2.satisfies(cleanVer, affected.vulnerableRange)) {
+      const cleanVer = semver3.clean(version) || version;
+      if (semver3.valid(cleanVer) && !semver3.satisfies(cleanVer, affected.vulnerableRange)) {
         continue;
       }
     }
@@ -2483,7 +2566,7 @@ async function evaluatePackage(packageName, options = {}) {
   }
   let recommendedVersion;
   if (isVulnerable) {
-    const upgradeCandidates = entries.map((e) => e.safeUpgradeVersion).filter((v) => Boolean(v && semver2.valid(v))).sort((a, b) => semver2.compare(a, b));
+    const upgradeCandidates = entries.map((e) => e.safeUpgradeVersion).filter((v) => Boolean(v && semver3.valid(v))).sort((a, b) => semver3.compare(a, b));
     recommendedVersion = upgradeCandidates[upgradeCandidates.length - 1] || latestVersion;
   } else {
     recommendedVersion = version || latestVersion;
@@ -2503,6 +2586,169 @@ async function evaluatePackage(packageName, options = {}) {
   };
 }
 
+// src/platform/safe-exec.ts
+import { execa as execa5 } from "execa";
+var DANGEROUS_ENV_VARS = /* @__PURE__ */ new Set([
+  "NODE_OPTIONS",
+  "NODE_PATH",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "PERL5OPT",
+  "PERL5LIB",
+  "PYTHONWARNINGS",
+  "PYTHONPATH",
+  "RUBYOPT",
+  "RUBYLIB",
+  "BASH_ENV",
+  "ENV"
+]);
+function sanitizeEnvironment(env = process.env, allowNodeOptions = false) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value === void 0) continue;
+    if (key.includes("\0") || typeof value === "string" && value.includes("\0")) continue;
+    if (DANGEROUS_ENV_VARS.has(key)) {
+      if (key === "NODE_OPTIONS" && allowNodeOptions) {
+        sanitized[key] = value;
+      }
+      continue;
+    }
+    sanitized[key] = value;
+  }
+  return sanitized;
+}
+function validateCommandArguments(file, args = []) {
+  if (file.includes("\0")) {
+    throw new Error("Command execution blocked: executable path contains null bytes");
+  }
+  for (const arg of args) {
+    if (arg.includes("\0")) {
+      throw new Error(`Command execution blocked: argument contains null bytes: ${arg}`);
+    }
+  }
+}
+function safeExeca(file, args = [], options = {}) {
+  validateCommandArguments(file, args);
+  const timeout = options.timeoutMs ?? (typeof options.timeout === "number" ? options.timeout : 6e4);
+  const sanitizedEnv = sanitizeEnvironment(
+    options.env ?? process.env,
+    options.allowNodeOptions
+  );
+  return execa5(file, args, {
+    ...options,
+    timeout,
+    env: sanitizedEnv
+  });
+}
+
+// src/remediation/tools/apply-package-override/helpers.ts
+async function collectDependencyTrace(cwd, pm, packageName, constraints) {
+  try {
+    const whyCommand = resolveWhyCommand(pm, packageName, constraints);
+    if (whyCommand.length === 0) return void 0;
+    const [whyCmd, ...whyArgs] = whyCommand;
+    const result = await safeExeca(whyCmd, whyArgs, {
+      cwd,
+      stdio: "pipe",
+      reject: false
+    });
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").split("\n").map((line) => line.trim()).filter(Boolean);
+    if (output.length === 0) return void 0;
+    return output.slice(0, 3).join(" | ");
+  } catch {
+    return void 0;
+  }
+}
+function describeOverrideField(packageManager) {
+  if (packageManager === "npm" || packageManager === "bun") return "overrides";
+  if (packageManager === "pnpm") return "pnpm.overrides";
+  if (packageManager === "deno") return "overrides";
+  return "resolutions";
+}
+function getOverrideValue(pkgJson, packageManager, packageName) {
+  if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno") {
+    return pkgJson.overrides?.[packageName];
+  }
+  if (packageManager === "pnpm") return pkgJson.pnpm?.overrides?.[packageName];
+  return pkgJson.resolutions?.[packageName];
+}
+function setOverrideValue(pkgJson, packageManager, packageName, version) {
+  if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno") {
+    pkgJson.overrides = { ...pkgJson.overrides, [packageName]: version };
+    return;
+  }
+  if (packageManager === "pnpm") {
+    pkgJson.pnpm = {
+      ...pkgJson.pnpm,
+      overrides: {
+        ...pkgJson.pnpm?.overrides,
+        [packageName]: version
+      }
+    };
+    return;
+  }
+  pkgJson.resolutions = { ...pkgJson.resolutions, [packageName]: version };
+}
+function restoreOverrideValue(pkgJson, packageManager, packageName, previousValue) {
+  if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno") {
+    pkgJson.overrides = restoreRecord(pkgJson.overrides, packageName, previousValue);
+    return;
+  }
+  if (packageManager === "pnpm") {
+    pkgJson.pnpm = {
+      ...pkgJson.pnpm,
+      overrides: restoreRecord(pkgJson.pnpm?.overrides, packageName, previousValue)
+    };
+    if (!pkgJson.pnpm.overrides) {
+      delete pkgJson.pnpm.overrides;
+    }
+    if (Object.keys(pkgJson.pnpm).length === 0) {
+      delete pkgJson.pnpm;
+    }
+    return;
+  }
+  pkgJson.resolutions = restoreRecord(pkgJson.resolutions, packageName, previousValue);
+}
+function getDenoJsonImportValue(denoJson, packageName) {
+  const imports = denoJson.imports ?? {};
+  if (imports[packageName] !== void 0) {
+    return { key: packageName, value: imports[packageName] };
+  }
+  const npmKey = `npm:${packageName}`;
+  if (imports[npmKey] !== void 0) {
+    return { key: npmKey, value: imports[npmKey] };
+  }
+  return void 0;
+}
+function setDenoJsonImportValue(denoJson, packageName, version) {
+  const existing = getDenoJsonImportValue(denoJson, packageName);
+  const key = existing?.key ?? `npm:${packageName}`;
+  denoJson.imports = { ...denoJson.imports, [key]: `npm:${packageName}@${version}` };
+}
+function restoreDenoJsonImportValue(denoJson, packageName, previousEntry) {
+  const existing = getDenoJsonImportValue(denoJson, packageName);
+  if (!existing) return;
+  const imports = { ...denoJson.imports };
+  if (previousEntry === void 0) {
+    delete imports[existing.key];
+  } else {
+    delete imports[existing.key];
+    imports[previousEntry.key] = previousEntry.value;
+  }
+  denoJson.imports = Object.keys(imports).length > 0 ? imports : void 0;
+}
+function restoreRecord(record, key, previousValue) {
+  const nextRecord = { ...record };
+  if (previousValue === void 0) {
+    delete nextRecord[key];
+  } else {
+    nextRecord[key] = previousValue;
+  }
+  return Object.keys(nextRecord).length > 0 ? nextRecord : void 0;
+}
+
 // src/api/patches/reconcile.ts
 async function reconcilePatchArtifacts(options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -2556,7 +2802,8 @@ async function reconcilePatchArtifacts(options = {}) {
           (v) => v.safeUpgradeVersion
         )?.safeUpgradeVersion;
       }
-    } catch {
+    } catch (evalError) {
+      const _ignored = evalError;
     }
     if (!safeUpgradeVersion) {
       results.push({
@@ -2581,10 +2828,23 @@ async function reconcilePatchArtifacts(options = {}) {
       });
       continue;
     }
+    const pkgJsonPath = join10(cwd, "package.json");
+    const manifestPath = inspection.manifestFilePath ?? `${summary.patchFilePath}.json`;
+    let originalPkgJsonContent;
+    let originalPatchContent;
+    let originalManifestContent;
     try {
-      const pkgJsonPath = join10(cwd, "package.json");
-      if (existsSync8(pkgJsonPath)) {
-        const pkgJson = JSON.parse(await readFile3(pkgJsonPath, "utf8"));
+      if (existsSync9(pkgJsonPath)) {
+        originalPkgJsonContent = await readFile3(pkgJsonPath, "utf8");
+      }
+      if (existsSync9(summary.patchFilePath)) {
+        originalPatchContent = await readFile3(summary.patchFilePath, "utf8");
+      }
+      if (existsSync9(manifestPath)) {
+        originalManifestContent = await readFile3(manifestPath, "utf8");
+      }
+      if (originalPkgJsonContent) {
+        const pkgJson = JSON.parse(originalPkgJsonContent);
         let updated = false;
         const depSections = [
           "dependencies",
@@ -2592,16 +2852,24 @@ async function reconcilePatchArtifacts(options = {}) {
           "peerDependencies",
           "optionalDependencies"
         ];
+        let foundInDirectDeps = false;
         for (const depSection of depSections) {
           if (pkgJson[depSection] && pkgJson[depSection][packageName]) {
             pkgJson[depSection][packageName] = `^${safeUpgradeVersion}`;
             updated = true;
+            foundInDirectDeps = true;
           }
         }
+        const existingOverride = getOverrideValue(pkgJson, pm, packageName);
+        if (existingOverride || !foundInDirectDeps) {
+          setOverrideValue(pkgJson, pm, packageName, safeUpgradeVersion);
+          updated = true;
+        }
         if (pkgJson.pnpm?.patchedDependencies) {
-          for (const key of Object.keys(pkgJson.pnpm.patchedDependencies)) {
+          const patched = pkgJson.pnpm.patchedDependencies;
+          for (const key of Object.keys(patched)) {
             if (key.startsWith(`${packageName}@`)) {
-              delete pkgJson.pnpm.patchedDependencies[key];
+              delete patched[key];
               updated = true;
             }
           }
@@ -2611,14 +2879,60 @@ async function reconcilePatchArtifacts(options = {}) {
         }
       }
       await rm(summary.patchFilePath, { force: true });
-      if (inspection.manifestFilePath) {
-        await rm(inspection.manifestFilePath, { force: true });
+      if (existsSync9(manifestPath)) {
+        await rm(manifestPath, { force: true });
       }
       const installCmd = resolveInstallCommand(pm);
-      await execa5(installCmd[0], installCmd.slice(1), { cwd, reject: false });
+      try {
+        await safeExeca(installCmd[0], installCmd.slice(1), { cwd, stdio: "pipe" });
+      } catch (installErr) {
+        if (originalPkgJsonContent) {
+          await writeFile(pkgJsonPath, originalPkgJsonContent, "utf8");
+        }
+        if (originalPatchContent) {
+          await writeFile(summary.patchFilePath, originalPatchContent, "utf8");
+        }
+        if (originalManifestContent) {
+          await writeFile(manifestPath, originalManifestContent, "utf8");
+        }
+        const msg = installErr instanceof Error ? installErr.message : String(installErr);
+        results.push({
+          patchFilePath: summary.patchFilePath,
+          packageName,
+          cveId,
+          installedVersion: vulnerableVersion,
+          safeUpstreamVersion: safeUpgradeVersion,
+          status: "error",
+          reason: `Package manager installation failed (${installCmd.join(" ")}): ${msg}. Restored original package.json and patch artifacts.`
+        });
+        continue;
+      }
       if (options.runTests) {
         const testCmd = resolveTestCommand(pm);
-        await execa5(testCmd[0], testCmd.slice(1), { cwd, reject: false });
+        try {
+          await safeExeca(testCmd[0], testCmd.slice(1), { cwd, stdio: "pipe" });
+        } catch (testErr) {
+          if (originalPkgJsonContent) {
+            await writeFile(pkgJsonPath, originalPkgJsonContent, "utf8");
+          }
+          if (originalPatchContent) {
+            await writeFile(summary.patchFilePath, originalPatchContent, "utf8");
+          }
+          if (originalManifestContent) {
+            await writeFile(manifestPath, originalManifestContent, "utf8");
+          }
+          const msg = testErr instanceof Error ? testErr.message : String(testErr);
+          results.push({
+            patchFilePath: summary.patchFilePath,
+            packageName,
+            cveId,
+            installedVersion: vulnerableVersion,
+            safeUpstreamVersion: safeUpgradeVersion,
+            status: "error",
+            reason: `Validation tests failed post-upgrade (${testCmd.join(" ")}): ${msg}. Restored original package.json and patch artifacts.`
+          });
+          continue;
+        }
       }
       results.push({
         patchFilePath: summary.patchFilePath,
@@ -2653,7 +2967,7 @@ async function reconcilePatchArtifacts(options = {}) {
 }
 
 // src/platform/idempotency.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 import { join as join11 } from "path";
 var DEFAULT_INDEX = {
   schemaVersion: "1.0",
@@ -2667,9 +2981,9 @@ function entryKey(idempotencyKey, cveId) {
 }
 function loadIndex(cwd) {
   const filePath = indexFilePath(cwd);
-  if (!existsSync9(filePath)) return DEFAULT_INDEX;
+  if (!existsSync10(filePath)) return DEFAULT_INDEX;
   try {
-    const parsed = JSON.parse(readFileSync8(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync9(filePath, "utf8"));
     if (parsed && parsed.schemaVersion === "1.0" && parsed.entries) {
       return parsed;
     }
@@ -2680,8 +2994,8 @@ function loadIndex(cwd) {
 }
 function saveIndex(cwd, index) {
   const filePath = indexFilePath(cwd);
-  mkdirSync2(join11(cwd, ".autoremediator", "state"), { recursive: true });
-  writeFileSync2(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
+  mkdirSync4(join11(cwd, ".autoremediator", "state"), { recursive: true });
+  writeFileSync4(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
 }
 function readIdempotentReport(cwd, idempotencyKey, cveId) {
   const index = loadIndex(cwd);
@@ -2704,7 +3018,7 @@ function storeIdempotentReport(cwd, idempotencyKey, cveId, report) {
 import { generateText as generateText2 } from "ai";
 
 // src/remediation/local/run.ts
-import semver6 from "semver";
+import semver7 from "semver";
 
 // src/intelligence/sources/github-advisory.ts
 var GITHUB_API_BASE = "https://api.github.com/advisories";
@@ -2843,9 +3157,9 @@ async function enrichWithNvd(details) {
 }
 
 // src/intelligence/sources/snapshot.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 function loadIntelligenceSnapshot(filePath) {
-  const raw = readFileSync9(filePath, "utf8");
+  const raw = readFileSync10(filePath, "utf8");
   const parsed = JSON.parse(raw);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error(`Intelligence snapshot at ${filePath} must be a JSON object keyed by CVE ID.`);
@@ -2853,11 +3167,37 @@ function loadIntelligenceSnapshot(filePath) {
   return parsed;
 }
 function lookupSnapshotCve(snapshot, cveId) {
-  return snapshot[cveId.toUpperCase()] ?? snapshot[cveId] ?? null;
+  const store = snapshot.cves && typeof snapshot.cves === "object" && !Array.isArray(snapshot.cves) ? snapshot.cves : snapshot;
+  const normalizedId = cveId.toUpperCase();
+  const rawEntry = store[normalizedId] ?? store[cveId] ?? store[cveId.toLowerCase()];
+  if (!rawEntry || typeof rawEntry !== "object") return null;
+  if (typeof rawEntry.id === "string" && Array.isArray(rawEntry.affectedPackages) && typeof rawEntry.summary === "string") {
+    return rawEntry;
+  }
+  const affectedPackages = Array.isArray(rawEntry.affectedPackages) ? rawEntry.affectedPackages : rawEntry.packageName ? [
+    {
+      name: rawEntry.packageName,
+      ecosystem: "npm",
+      vulnerableRange: rawEntry.vulnerableRange ?? "",
+      firstPatchedVersion: rawEntry.firstPatchedVersion,
+      source: "offline-snapshot"
+    }
+  ] : [];
+  const details = {
+    id: rawEntry.id ?? rawEntry.cveId ?? normalizedId,
+    summary: rawEntry.summary ?? `Offline intelligence details for ${normalizedId}`,
+    severity: rawEntry.severity ?? "UNKNOWN",
+    references: Array.isArray(rawEntry.references) ? rawEntry.references : [],
+    affectedPackages,
+    cvssScore: typeof rawEntry.cvssScore === "number" ? rawEntry.cvssScore : void 0,
+    epss: rawEntry.epss ?? (typeof rawEntry.epssScore === "number" ? { score: rawEntry.epssScore, percentile: rawEntry.epssScore } : void 0),
+    kev: rawEntry.kev ?? (rawEntry.cisaKev !== void 0 ? { knownExploited: Boolean(rawEntry.cisaKev) } : void 0)
+  };
+  return details;
 }
 
 // src/remediation/tools/check-reachability.ts
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
 import { isAbsolute as isAbsolute2, join as join12, resolve as resolve3 } from "path";
 import { parseSync } from "oxc-parser";
 import { z as z2 } from "zod";
@@ -2875,9 +3215,9 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 function loadTsconfigPaths(cwd) {
   for (const configName of ["tsconfig.json", "jsconfig.json"]) {
     const fullPath = join12(cwd, configName);
-    if (!existsSync10(fullPath)) continue;
+    if (!existsSync11(fullPath)) continue;
     try {
-      const raw = readFileSync10(fullPath, "utf8");
+      const raw = readFileSync11(fullPath, "utf8");
       const cleaned = raw.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "");
       const parsed = JSON.parse(cleaned);
       const compilerOptions = parsed.compilerOptions;
@@ -2971,9 +3311,9 @@ function toRootPackageName(importSource) {
 function findTransitiveDependencyPath(cwd, targetPackage, importedDirectPackages) {
   for (const directPkg of importedDirectPackages) {
     const manifestPath = join12(cwd, "node_modules", directPkg, "package.json");
-    if (!existsSync10(manifestPath)) continue;
+    if (!existsSync11(manifestPath)) continue;
     try {
-      const manifest = JSON.parse(readFileSync10(manifestPath, "utf8"));
+      const manifest = JSON.parse(readFileSync11(manifestPath, "utf8"));
       if (manifest.dependencies && manifest.dependencies[targetPackage]) {
         return {
           directDependency: directPkg,
@@ -3146,7 +3486,7 @@ function assessPackageReachability(cwd, packageName, targetSymbol) {
     scanned++;
     let content;
     try {
-      content = readFileSync10(filePath, "utf8");
+      content = readFileSync11(filePath, "utf8");
     } catch {
       continue;
     }
@@ -3390,85 +3730,295 @@ function buildSbom(packages, vulnerableNames, results) {
 
 // src/remediation/tools/apply-version-bump.ts
 import { z as z4 } from "zod";
-import { join as join15 } from "path";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
+import { join as join16 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
+import { rm as rm3 } from "fs/promises";
+import semver4 from "semver";
 
-// src/platform/safe-exec.ts
-import { execa as execa6 } from "execa";
-var DANGEROUS_ENV_VARS = /* @__PURE__ */ new Set([
-  "NODE_OPTIONS",
-  "NODE_PATH",
-  "LD_PRELOAD",
-  "LD_LIBRARY_PATH",
-  "DYLD_INSERT_LIBRARIES",
-  "DYLD_LIBRARY_PATH",
-  "PERL5OPT",
-  "PERL5LIB",
-  "PYTHONWARNINGS",
-  "PYTHONPATH",
-  "RUBYOPT",
-  "RUBYLIB",
-  "BASH_ENV",
-  "ENV"
-]);
-function sanitizeEnvironment(env = process.env, allowNodeOptions = false) {
-  const sanitized = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (value === void 0) continue;
-    if (key.includes("\0") || typeof value === "string" && value.includes("\0")) continue;
-    if (DANGEROUS_ENV_VARS.has(key)) {
-      if (key === "NODE_OPTIONS" && allowNodeOptions) {
-        sanitized[key] = value;
-      }
-      continue;
-    }
-    sanitized[key] = value;
+// src/remediation/proof-of-fix/runner.ts
+import { existsSync as existsSync12 } from "fs";
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join13 } from "path";
+function sanitizePathLeakage(text, paths = []) {
+  let sanitized = text;
+  for (const p of paths) {
+    if (!p || p.trim().length === 0) continue;
+    sanitized = sanitized.split(p).join("<path>");
   }
   return sanitized;
 }
-function validateCommandArguments(file, args = []) {
-  if (file.includes("\0")) {
-    throw new Error("Command execution blocked: executable path contains null bytes");
+function stripStackTraceFrames(text) {
+  return text.split("\n").filter((line) => !/^\s*at\s+/.test(line)).join("\n");
+}
+function isHarnessFailure(context) {
+  const { exitCode, output, errorMsg = "", signal } = context;
+  const errorMsgEmbedsPath = errorMsg.includes("Command failed") || context.testFilePath && errorMsg.includes(context.testFilePath) || errorMsg.includes("/") || errorMsg.includes("\\");
+  const filteredErrorMsg = errorMsgEmbedsPath ? "" : errorMsg;
+  const combined = filteredErrorMsg ? `${output}
+${filteredErrorMsg}` : output;
+  if (signal !== void 0) {
+    return true;
   }
-  for (const arg of args) {
-    if (arg.includes("\0")) {
-      throw new Error(`Command execution blocked: argument contains null bytes: ${arg}`);
+  if (typeof exitCode === "number" && (exitCode === 126 || exitCode === 127 || exitCode > 128)) {
+    return true;
+  }
+  if (combined.includes("ENOENT") || combined.includes("no such file or directory")) {
+    return true;
+  }
+  if (combined.includes("bad option:") || combined.includes("bad option") || combined.includes("Unrecognized option") || combined.includes("illegal option") || combined.includes("invalid option")) {
+    return true;
+  }
+  if (combined.includes("SyntaxError") || combined.includes("Unexpected token") || combined.includes("Cannot use import statement outside a module")) {
+    return true;
+  }
+  if (combined.includes("Cannot find module") || combined.includes("Cannot find package") || combined.includes("MODULE_NOT_FOUND") || combined.includes("ERR_MODULE_NOT_FOUND") || combined.includes("ERR_REQUIRE_ESM") || combined.includes("ERR_UNKNOWN_FILE_EXTENSION") || combined.includes("ERR_PACKAGE_PATH_NOT_EXPORTED") || combined.includes("ERR_PACKAGE_IMPORT_NOT_DEFINED") || combined.includes("ERR_UNSUPPORTED_DIR_IMPORT") || combined.includes("ERR_UNSUPPORTED_ESM_URL_SCHEME") || combined.includes("ERR_INVALID_MODULE_SPECIFIER")) {
+    return true;
+  }
+  if (combined.includes("Allocation failed - JavaScript heap out of memory") || combined.includes("FATAL ERROR:") || combined.includes("UnhandledPromiseRejection:") || combined.includes("ERR_UNHANDLED_REJECTION") || combined.includes("(Use `node --trace-uncaught") || /^\s*(?!(?:AssertionError)\b)[A-Z]\w*Error:\s/m.test(combined)) {
+    return true;
+  }
+  return false;
+}
+function isAssertionFailure(output, exitCode) {
+  if (exitCode !== 1) {
+    return false;
+  }
+  const nonStackOutput = stripStackTraceFrames(output);
+  const hasUnhandledCrash = /^\s*(?:(?!(?:AssertionError)\b)[A-Z]\w*Error|Error|UnhandledPromiseRejection):\s/m.test(
+    nonStackOutput
+  ) || /^\s*FATAL ERROR:/m.test(nonStackOutput) || /\(Use `node --trace-uncaught/m.test(nonStackOutput);
+  if (hasUnhandledCrash) {
+    return false;
+  }
+  return /^\s*AssertionError(?:\s*\[ERR_ASSERTION\])?(?::|$)/m.test(nonStackOutput) || /^\s*(?:Error\s*)?\[ERR_ASSERTION\](?::|$)/m.test(nonStackOutput) || /^\s*ERR_ASSERTION(?::|\s*$)/m.test(nonStackOutput) || /^\s*EXPLOIT_REPRODUCED(?::|\s*$)/m.test(nonStackOutput) || /^\s*Assertion failed(?::|$)/im.test(nonStackOutput);
+}
+async function prepareReproductionTestFile(params) {
+  const {
+    cwd,
+    packageName,
+    vulnerableVersion,
+    patchesDir = "./patches",
+    proofOfFix,
+    reproductionTest
+  } = params;
+  const patchesDirPath = isAbsolute3(patchesDir) ? patchesDir : join13(cwd, patchesDir);
+  const safeName = packageName.replace(/^@/, "").replace(/\//g, "+");
+  const defaultTestPath = join13(patchesDirPath, `${safeName}+${vulnerableVersion}.test.cjs`);
+  if (typeof proofOfFix === "string" && proofOfFix.trim().length > 0) {
+    const resolvedPath = isAbsolute3(proofOfFix) ? proofOfFix : join13(cwd, proofOfFix);
+    if (existsSync12(resolvedPath)) {
+      return { testFilePath: resolvedPath, isCreated: false };
     }
+    await mkdir(patchesDirPath, { recursive: true });
+    await writeFile2(defaultTestPath, proofOfFix, "utf8");
+    return { testFilePath: defaultTestPath, isCreated: true };
   }
+  if (reproductionTest && reproductionTest.trim().length > 0) {
+    const resolvedPath = isAbsolute3(reproductionTest) ? reproductionTest : join13(cwd, reproductionTest);
+    if (existsSync12(resolvedPath)) {
+      return { testFilePath: resolvedPath, isCreated: false };
+    }
+    await mkdir(patchesDirPath, { recursive: true });
+    await writeFile2(defaultTestPath, reproductionTest, "utf8");
+    return { testFilePath: defaultTestPath, isCreated: true };
+  }
+  if (proofOfFix === true && existsSync12(defaultTestPath)) {
+    return { testFilePath: defaultTestPath, isCreated: false };
+  }
+  return { testFilePath: void 0, isCreated: false };
 }
-function safeExeca(file, args = [], options = {}) {
-  validateCommandArguments(file, args);
-  const timeout = options.timeoutMs ?? (typeof options.timeout === "number" ? options.timeout : 6e4);
-  const sanitizedEnv = sanitizeEnvironment(
-    options.env ?? process.env,
-    options.allowNodeOptions
-  );
-  return execa6(file, args, {
-    ...options,
-    timeout,
-    env: sanitizedEnv
-  });
+async function runProofOfFixPhase(options) {
+  const { stage, testFilePath, cwd, timeoutMs = 15e3 } = options;
+  const started = Date.now();
+  const isTs = testFilePath.endsWith(".ts");
+  const nodeArgs = isTs ? ["--experimental-strip-types", testFilePath] : [testFilePath];
+  try {
+    const result = await safeExeca("node", nodeArgs, {
+      cwd,
+      timeoutMs,
+      stdio: "pipe"
+    });
+    const durationMs = Date.now() - started;
+    const stdout = String(result.stdout ?? "");
+    const stderr = String(result.stderr ?? "");
+    const output = `${stdout}
+${stderr}`.trim();
+    if (stage === "negative") {
+      return {
+        executed: true,
+        passed: false,
+        exitCode: 0,
+        output,
+        durationMs,
+        error: "Exploit reproduction test passed on vulnerable target (failed to reproduce vulnerability)."
+      };
+    }
+    return {
+      executed: true,
+      passed: true,
+      exitCode: 0,
+      output,
+      durationMs
+    };
+  } catch (err) {
+    const durationMs = Date.now() - started;
+    const execaErr = err;
+    const exitCode = typeof execaErr.exitCode === "number" ? execaErr.exitCode : 1;
+    const errorMsg = execaErr.message || String(err);
+    const rawStdout = String(execaErr.stdout ?? "").trim();
+    const rawStderr = String(execaErr.stderr ?? "").trim();
+    const processOutput = [rawStdout, rawStderr].filter(Boolean).join("\n").trim();
+    const output = processOutput || errorMsg;
+    if (stage === "negative") {
+      if (execaErr.timedOut || errorMsg.includes("timed out") || output.includes("timed out") || execaErr.code === "ETIMEDOUT") {
+        return {
+          executed: true,
+          passed: false,
+          harnessFailure: true,
+          exitCode,
+          output,
+          durationMs,
+          error: "Exploit reproduction test timed out (execution hung)."
+        };
+      }
+      if (isHarnessFailure({
+        exitCode,
+        output,
+        errorMsg,
+        testFilePath,
+        signal: execaErr.signal
+      })) {
+        return {
+          executed: false,
+          passed: false,
+          harnessFailure: true,
+          exitCode,
+          output,
+          durationMs,
+          error: `Reproduction test failed to execute (harness error): ${errorMsg}`
+        };
+      }
+      const knownPaths = [
+        cwd,
+        testFilePath,
+        isAbsolute3(testFilePath) ? testFilePath : join13(cwd, testFilePath)
+      ];
+      if (rawStderr) {
+        const stderrSanitized = sanitizePathLeakage(stripStackTraceFrames(rawStderr), knownPaths);
+        if (isAssertionFailure(stderrSanitized, exitCode)) {
+          return {
+            executed: true,
+            passed: true,
+            exitCode,
+            output,
+            durationMs
+          };
+        }
+        const hasStderrCrash = /^\s*(?:(?!(?:AssertionError)\b)[A-Z]\w*Error|Error|UnhandledPromiseRejection|UnhandledPromiseRejectionWarning):\s/m.test(
+          stderrSanitized
+        ) || /^\s*FATAL ERROR:/m.test(stderrSanitized) || stderrSanitized.includes("Allocation failed - JavaScript heap out of memory") || /\(Use `node --trace-uncaught/m.test(rawStderr) || /\bERR_UNHANDLED_REJECTION\b/.test(rawStderr) || /^\s*at\s+/m.test(rawStderr) || /Node\.js v\d+/m.test(rawStderr);
+        if (hasStderrCrash) {
+          return {
+            executed: false,
+            passed: false,
+            harnessFailure: true,
+            exitCode,
+            output,
+            durationMs,
+            error: `Reproduction test failed with runtime error instead of exploit assertion: ${errorMsg}`
+          };
+        }
+      }
+      if (rawStdout) {
+        const stdoutSanitized = sanitizePathLeakage(stripStackTraceFrames(rawStdout), knownPaths);
+        if (isAssertionFailure(stdoutSanitized, exitCode)) {
+          return {
+            executed: true,
+            passed: true,
+            exitCode,
+            output,
+            durationMs
+          };
+        }
+      }
+      if (errorMsg) {
+        const errorMsgSanitized = sanitizePathLeakage(stripStackTraceFrames(errorMsg), knownPaths);
+        if (isAssertionFailure(errorMsgSanitized, exitCode)) {
+          return {
+            executed: true,
+            passed: true,
+            exitCode,
+            output,
+            durationMs
+          };
+        }
+      }
+      return {
+        executed: false,
+        passed: false,
+        harnessFailure: true,
+        exitCode,
+        output,
+        durationMs,
+        error: `Reproduction test failed with runtime error instead of exploit assertion: ${errorMsg}`
+      };
+    }
+    return {
+      executed: true,
+      passed: false,
+      exitCode,
+      output,
+      durationMs,
+      error: `Reproduction test failed on patched target: ${errorMsg}`
+    };
+  }
+}
+function assembleProofOfFixVerification(params) {
+  const { reproductionTestPath, negativePhase, positivePhase, regressionPhase } = params;
+  const regPhase = regressionPhase ?? {
+    executed: false,
+    passed: true
+  };
+  let status = "verified";
+  let failureReason;
+  if (!negativePhase.passed) {
+    status = "failed";
+    failureReason = negativePhase.error || "negative-phase-failed";
+  } else if (!positivePhase.passed) {
+    status = "failed";
+    failureReason = positivePhase.error || "positive-phase-failed";
+  } else if (regPhase.executed && !regPhase.passed) {
+    status = "failed";
+    failureReason = regPhase.error || "regression-phase-failed";
+  }
+  const durationMs = (negativePhase.durationMs || 0) + (positivePhase.durationMs || 0) + (regPhase.durationMs || 0);
+  return {
+    status,
+    reproductionTestPath,
+    negativePhase,
+    positivePhase,
+    regressionPhase: regPhase,
+    durationMs,
+    failureReason
+  };
 }
-
-// src/remediation/tools/apply-version-bump.ts
-import semver3 from "semver";
 
 // src/platform/repo-lock.ts
-import { mkdir, rm as rm2 } from "fs/promises";
-import { join as join13 } from "path";
+import { mkdir as mkdir2, rm as rm2 } from "fs/promises";
+import { join as join14 } from "path";
 async function sleep(ms) {
-  await new Promise((resolve6) => setTimeout(resolve6, ms));
+  await new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function acquireRepoLock(cwd, options = {}) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const retryDelayMs = options.retryDelayMs ?? 125;
-  const lockRoot = join13(cwd, ".autoremediator", "locks");
-  const lockPath = join13(cwd, ".autoremediator", "locks", "remediation.lock");
+  const lockRoot = join14(cwd, ".autoremediator", "locks");
+  const lockPath = join14(cwd, ".autoremediator", "locks", "remediation.lock");
   const startedAt = Date.now();
-  await mkdir(lockRoot, { recursive: true });
+  await mkdir2(lockRoot, { recursive: true });
   while (true) {
     try {
-      await mkdir(lockPath, { recursive: false });
+      await mkdir2(lockPath, { recursive: false });
       return {
         lockPath,
         release: async () => {
@@ -3493,8 +4043,8 @@ async function withRepoLock(cwd, fn, options) {
 }
 
 // src/remediation/refactor/call-site-finder.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
-import { join as join14 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { join as join15 } from "path";
 import { parseSync as parseSync2 } from "oxc-parser";
 var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]);
 var IGNORED_DIRS2 = /* @__PURE__ */ new Set([
@@ -3516,7 +4066,7 @@ function* walkFiles(dir) {
   }
   for (const entry of entries) {
     if (IGNORED_DIRS2.has(entry)) continue;
-    const full = join14(dir, entry);
+    const full = join15(dir, entry);
     let stat2;
     try {
       stat2 = statSync3(full);
@@ -3538,7 +4088,7 @@ function findPackageCallSites(cwd, packageName) {
   for (const filePath of walkFiles(cwd)) {
     let content;
     try {
-      content = readFileSync11(filePath, "utf8");
+      content = readFileSync12(filePath, "utf8");
     } catch {
       continue;
     }
@@ -3546,6 +4096,94 @@ function findPackageCallSites(cwd, packageName) {
       continue;
     }
     try {
+      let getLineCol2 = function(offset) {
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low <= high) {
+          const mid = Math.floor((low + high) / 2);
+          if (lineStarts[mid] <= offset) {
+            if (mid === lineStarts.length - 1 || lineStarts[mid + 1] > offset) {
+              return { line: mid + 1, column: offset - lineStarts[mid] + 1 };
+            }
+            low = mid + 1;
+          } else {
+            high = mid - 1;
+          }
+        }
+        return { line: 1, column: offset + 1 };
+      }, walk2 = function(node, parentType) {
+        if (!node || typeof node !== "object") return;
+        if (node.type === "CallExpression") {
+          let localSymbol = "";
+          let memberName;
+          if (node.callee?.type === "Identifier" && localNames.has(node.callee.name)) {
+            localSymbol = node.callee.name;
+          } else if (node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && localNames.has(node.callee.object.name)) {
+            localSymbol = node.callee.object.name;
+            memberName = node.callee.property?.name;
+          }
+          if (localSymbol) {
+            const { line, column } = getLineCol2(node.start);
+            referencedLinesSet.add(line);
+            const argumentSpans = (node.arguments || []).map((arg) => ({
+              start: arg.start,
+              end: arg.end,
+              text: content.slice(arg.start, arg.end)
+            }));
+            astCallSites.push({
+              start: node.start,
+              end: node.end,
+              line,
+              column,
+              calleeText: content.slice(node.callee.start, node.callee.end),
+              expressionType: "call",
+              localSymbol,
+              memberName,
+              argumentCount: (node.arguments || []).length,
+              argumentSpans
+            });
+          }
+        } else if (node.type === "MemberExpression") {
+          if (node.object?.type === "Identifier" && localNames.has(node.object.name)) {
+            const { line, column } = getLineCol2(node.start);
+            referencedLinesSet.add(line);
+            if (parentType !== "CallExpression") {
+              astCallSites.push({
+                start: node.start,
+                end: node.end,
+                line,
+                column,
+                calleeText: content.slice(node.start, node.end),
+                expressionType: "property-access",
+                localSymbol: node.object.name,
+                memberName: node.property?.name,
+                argumentCount: 0,
+                argumentSpans: []
+              });
+            }
+          }
+        } else if (node.type === "Identifier") {
+          if (localNames.has(node.name)) {
+            const isImportDecl = Boolean(parentType?.startsWith("Import"));
+            if (!isImportDecl) {
+              const { line } = getLineCol2(node.start);
+              referencedLinesSet.add(line);
+            }
+          }
+        }
+        for (const key of Object.keys(node)) {
+          if (key === "parent") continue;
+          const child = node[key];
+          if (Array.isArray(child)) {
+            for (const item of child) {
+              walk2(item, node.type);
+            }
+          } else if (child && typeof child === "object") {
+            walk2(child, node.type);
+          }
+        }
+      };
+      var getLineCol = getLineCol2, walk = walk2;
       const parseResult = parseSync2(filePath, content);
       if (!parseResult.program) continue;
       const program = parseResult.program;
@@ -3554,7 +4192,7 @@ function findPackageCallSites(cwd, packageName) {
       const localNames = /* @__PURE__ */ new Set();
       for (const statement of program.body) {
         if (statement.type === "ImportDeclaration" && statement.source?.value) {
-          const importSource = statement.source.value;
+          const importSource = String(statement.source.value);
           if (importSource === packageName || importSource.startsWith(`${packageName}/`)) {
             importSources.push(importSource);
             for (const spec of statement.specifiers || []) {
@@ -3566,47 +4204,90 @@ function findPackageCallSites(cwd, packageName) {
                   localName,
                   importedName: "default",
                   isDefault: true,
-                  isNamespace: false
+                  isNamespace: false,
+                  kind: "default",
+                  start: spec.local?.start,
+                  end: spec.local?.end
                 });
               } else if (spec.type === "ImportNamespaceSpecifier") {
                 imports.push({
                   localName,
                   importedName: "*",
                   isDefault: false,
-                  isNamespace: true
+                  isNamespace: true,
+                  kind: "namespace",
+                  start: spec.local?.start,
+                  end: spec.local?.end
                 });
               } else if (spec.type === "ImportSpecifier") {
                 imports.push({
                   localName,
                   importedName: spec.imported?.name || localName,
                   isDefault: false,
-                  isNamespace: false
+                  isNamespace: false,
+                  kind: "named",
+                  start: spec.local?.start,
+                  end: spec.local?.end
                 });
               }
             }
           }
         }
-      }
-      if (imports.length > 0 || importSources.length > 0) {
-        const lines = content.split("\n");
-        const referencedLines = [];
-        lines.forEach((line, index) => {
-          for (const local of localNames) {
-            const regex = new RegExp(`\\b${local}\\b`);
-            if (regex.test(line)) {
-              referencedLines.push(index + 1);
-              break;
+        if (statement.type === "VariableDeclaration") {
+          for (const decl of statement.declarations || []) {
+            if (decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && decl.init.callee.name === "require" && decl.init.arguments?.[0]?.value) {
+              const importSource = String(decl.init.arguments[0].value);
+              if (importSource === packageName || importSource.startsWith(`${packageName}/`)) {
+                importSources.push(importSource);
+                if (decl.id?.type === "Identifier") {
+                  const localName = decl.id.name;
+                  localNames.add(localName);
+                  imports.push({
+                    localName,
+                    importedName: "default",
+                    isDefault: true,
+                    isNamespace: false,
+                    kind: "require-default"
+                  });
+                } else if (decl.id?.type === "ObjectPattern") {
+                  for (const prop of decl.id.properties || []) {
+                    const localName = prop.value?.name || prop.key?.name;
+                    if (localName) {
+                      localNames.add(localName);
+                      imports.push({
+                        localName,
+                        importedName: prop.key?.name || localName,
+                        isDefault: false,
+                        isNamespace: false,
+                        kind: "require-destructured"
+                      });
+                    }
+                  }
+                }
+              }
             }
           }
-        });
-        callSites.push({
-          filePath,
-          sourceContent: content,
-          importSources,
-          imports,
-          referencedLines
-        });
+        }
       }
+      if (imports.length === 0 && importSources.length === 0) {
+        continue;
+      }
+      const lineStarts = [0];
+      for (let i = 0; i < content.length; i++) {
+        if (content[i] === "\n") lineStarts.push(i + 1);
+      }
+      const referencedLinesSet = /* @__PURE__ */ new Set();
+      const astCallSites = [];
+      walk2(program);
+      const referencedLines = Array.from(referencedLinesSet).sort((a, b) => a - b);
+      callSites.push({
+        filePath,
+        sourceContent: content,
+        importSources,
+        imports,
+        referencedLines,
+        callSites: astCallSites
+      });
     } catch {
     }
   }
@@ -3614,7 +4295,17 @@ function findPackageCallSites(cwd, packageName) {
 }
 
 // src/remediation/refactor/refactor-agent.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
+import { parseSync as parseSync3 } from "oxc-parser";
+function applyEdits(source, edits) {
+  if (edits.length === 0) return source;
+  const sorted = [...edits].sort((a, b) => b.start - a.start);
+  let result = source;
+  for (const edit of sorted) {
+    result = result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
+  }
+  return result;
+}
 function parseCompilerDiagnostics(diagnosticError) {
   const diagnostics = [];
   const lines = diagnosticError.split("\n");
@@ -3649,173 +4340,332 @@ function parseCompilerDiagnostics(diagnosticError) {
 function revertRefactorSnapshots(snapshots) {
   for (const [filePath, content] of Object.entries(snapshots)) {
     try {
-      writeFileSync3(filePath, content, "utf8");
+      writeFileSync5(filePath, content, "utf8");
     } catch {
     }
   }
 }
-var KNOWN_MIGRATIONS = {
-  rimraf: [
-    {
-      detect: (content, diag) => diag.includes("sync") && content.includes("rimraf.sync("),
-      transform: (content) => {
-        let res = content.replace(/import\s+rimraf\s+from\s+['"]rimraf['"];?/g, "");
-        res = `import { rimrafSync } from "rimraf";
-` + res;
-        return res.replace(/rimraf\.sync\(/g, "rimrafSync(");
-      }
-    }
-  ],
-  uuid: [
-    {
-      detect: (content, diag) => diag.includes("v4") && content.includes("uuid.v4("),
-      transform: (content) => {
-        let res = content.replace(/import\s+uuid\s+from\s+['"]uuid['"];?/g, "");
-        res = `import { v4 as uuidv4 } from "uuid";
-` + res;
-        return res.replace(/uuid\.v4\(/g, "uuidv4(");
-      }
-    },
-    {
-      // Subpath import migration: `import v4 from "uuid/v4"` -> `import { v4 } from "uuid"`
-      detect: (content) => /from\s+['"]uuid\/v4['"]/.test(content),
-      transform: (content) => content.replace(
-        /import\s+([a-zA-Z0-9_$]+)\s+from\s+['"]uuid\/v4['"];?/g,
-        `import { v4 as $1 } from "uuid";`
-      )
-    }
-  ],
-  glob: [
-    {
-      detect: (content, diag) => diag.includes("sync") && content.includes("glob.sync("),
-      transform: (content) => {
-        let res = content.replace(/import\s+glob\s+from\s+['"]glob['"];?/g, "");
-        res = `import { globSync } from "glob";
-` + res;
-        return res.replace(/glob\.sync\(/g, "globSync(");
+function transformCallArguments(content, options) {
+  const parseResult = parseSync3(options.filePath ?? "file.ts", content);
+  if (!parseResult.program) {
+    return { modified: false, newContent: content };
+  }
+  const edits = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "CallExpression") {
+      const calleeText = content.slice(node.callee.start, node.callee.end);
+      const matchesCallee = calleeText === options.callee || calleeText.endsWith(`.${options.callee}`);
+      if (matchesCallee) {
+        const args = node.arguments || [];
+        if (options.dropIndex !== void 0) {
+          const idx = options.dropIndex;
+          if (idx >= 0 && idx < args.length) {
+            if (args.length === 1) {
+              edits.push({
+                start: args[0].start,
+                end: args[0].end,
+                replacement: ""
+              });
+            } else if (idx < args.length - 1) {
+              edits.push({
+                start: args[idx].start,
+                end: args[idx + 1].start,
+                replacement: ""
+              });
+            } else {
+              edits.push({
+                start: args[idx - 1].end,
+                end: args[idx].end,
+                replacement: ""
+              });
+            }
+          }
+        }
+        if (options.reorder) {
+          const [i, j] = options.reorder;
+          if (i >= 0 && j >= 0 && i < args.length && j < args.length && i !== j) {
+            const argIText = content.slice(args[i].start, args[i].end);
+            const argJText = content.slice(args[j].start, args[j].end);
+            edits.push({
+              start: args[i].start,
+              end: args[i].end,
+              replacement: argJText
+            });
+            edits.push({
+              start: args[j].start,
+              end: args[j].end,
+              replacement: argIText
+            });
+          }
+        }
       }
     }
-  ],
-  mkdirp: [
-    {
-      detect: (content, diag) => diag.includes("sync") && content.includes("mkdirp.sync("),
-      transform: (content) => {
-        let res = content.replace(/import\s+mkdirp\s+from\s+['"]mkdirp['"];?/g, "");
-        res = `import { mkdirpSync } from "mkdirp";
-` + res;
-        return res.replace(/mkdirp\.sync\(/g, "mkdirpSync(");
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item);
+      } else if (child && typeof child === "object") {
+        walk(child);
       }
     }
-  ]
-};
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  walk(parseResult.program);
+  if (edits.length === 0) {
+    return { modified: false, newContent: content };
+  }
+  return { modified: true, newContent: applyEdits(content, edits) };
 }
-function transformFileContent(content, packageName, diagnosticError, filePath) {
+function transformFileContent(content, packageName, diagnosticError, filePath, argumentTransforms) {
+  let currentContent = content;
   let modified = false;
-  let newContent = content;
-  const migrations = KNOWN_MIGRATIONS[packageName];
-  if (migrations) {
-    for (const mig of migrations) {
-      if (mig.detect(newContent, diagnosticError)) {
-        const transformed = mig.transform(newContent);
-        if (transformed !== newContent) {
-          newContent = transformed;
-          modified = true;
+  const parseResult = parseSync3(filePath ?? "file.ts", currentContent);
+  if (!parseResult.program) {
+    return { modified: false, newContent: content };
+  }
+  const edits = [];
+  const body = parseResult.program.body || [];
+  let defaultLocalName;
+  let namespaceLocalName;
+  let defaultImportDecl;
+  let subpathImportDecl;
+  let subpathName;
+  for (const statement of body) {
+    if (statement.type === "ImportDeclaration" && statement.source?.value) {
+      const specText = String(statement.source.value);
+      if (specText === packageName) {
+        for (const spec of statement.specifiers || []) {
+          if (spec.type === "ImportDefaultSpecifier") {
+            defaultLocalName = spec.local?.name;
+            defaultImportDecl = statement;
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            namespaceLocalName = spec.local?.name;
+          }
+        }
+      } else if (specText.startsWith(`${packageName}/`)) {
+        subpathImportDecl = statement;
+        subpathName = specText.slice(packageName.length + 1);
+        for (const spec of statement.specifiers || []) {
+          if (spec.type === "ImportDefaultSpecifier") {
+            defaultLocalName = spec.local?.name;
+          }
         }
       }
     }
   }
-  if (diagnosticError.includes("no default export") || diagnosticError.includes("has no exported member 'default'") || diagnosticError.includes("has no exported member default") || diagnosticError.includes("TS2614") || diagnosticError.includes("TS1192")) {
-    const defaultImportRegex = new RegExp(
-      `import\\s+([a-zA-Z0-9_$]+)\\s+from\\s+['"]${escapeRegex(packageName)}['"]`,
-      "g"
-    );
-    if (defaultImportRegex.test(newContent)) {
-      newContent = newContent.replace(
-        defaultImportRegex,
-        `import * as $1 from "${packageName}"`
-      );
-      modified = true;
-    }
+  if (subpathImportDecl && (diagnosticError.includes(`Cannot find module '${packageName}/`) || diagnosticError.includes(`Cannot find module "${packageName}/`))) {
+    const local = defaultLocalName || subpathName || "default";
+    const newImport = `import { ${subpathName} as ${local} } from "${packageName}";`;
+    edits.push({
+      start: subpathImportDecl.start,
+      end: subpathImportDecl.end,
+      replacement: newImport
+    });
+  }
+  if (packageName === "rimraf" && (diagnosticError.includes("sync") || diagnosticError.includes("rimrafSync") || currentContent.includes("rimraf.sync(") || defaultLocalName && currentContent.includes(`${defaultLocalName}.sync(`))) {
+    let walkRimraf2 = function(node) {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === targetLocal && node.callee.property?.name === "sync") {
+        edits.push({
+          start: node.callee.start,
+          end: node.callee.end,
+          replacement: "rimrafSync"
+        });
+      }
+      for (const k of Object.keys(node)) {
+        if (k === "parent") continue;
+        const v = node[k];
+        if (Array.isArray(v)) v.forEach(walkRimraf2);
+        else if (v && typeof v === "object") walkRimraf2(v);
+      }
+    };
+    var walkRimraf = walkRimraf2;
+    const targetLocal = defaultLocalName || "rimraf";
+    walkRimraf2(parseResult.program);
+    if (defaultImportDecl) {
+      edits.push({
+        start: defaultImportDecl.start,
+        end: defaultImportDecl.end,
+        replacement: `import { rimrafSync } from "rimraf";`
+      });
+    }
+  }
+  if (packageName === "uuid" && (diagnosticError.includes("v4") || diagnosticError.includes("uuidv4") || currentContent.includes("uuid.v4(") || defaultLocalName && currentContent.includes(`${defaultLocalName}.v4(`))) {
+    let walkUuid2 = function(node) {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === targetLocal && node.callee.property?.name === "v4") {
+        edits.push({
+          start: node.callee.start,
+          end: node.callee.end,
+          replacement: "uuidv4"
+        });
+      }
+      for (const k of Object.keys(node)) {
+        if (k === "parent") continue;
+        const v = node[k];
+        if (Array.isArray(v)) v.forEach(walkUuid2);
+        else if (v && typeof v === "object") walkUuid2(v);
+      }
+    };
+    var walkUuid = walkUuid2;
+    const targetLocal = defaultLocalName || "uuid";
+    walkUuid2(parseResult.program);
+    if (defaultImportDecl) {
+      edits.push({
+        start: defaultImportDecl.start,
+        end: defaultImportDecl.end,
+        replacement: `import { v4 as uuidv4 } from "uuid";`
+      });
+    }
+  }
+  if (packageName === "glob" && (diagnosticError.includes("sync") || diagnosticError.includes("globSync") || currentContent.includes("glob.sync(") || defaultLocalName && currentContent.includes(`${defaultLocalName}.sync(`))) {
+    let walkGlob2 = function(node) {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === targetLocal && node.callee.property?.name === "sync") {
+        edits.push({
+          start: node.callee.start,
+          end: node.callee.end,
+          replacement: "globSync"
+        });
+      }
+      for (const k of Object.keys(node)) {
+        if (k === "parent") continue;
+        const v = node[k];
+        if (Array.isArray(v)) v.forEach(walkGlob2);
+        else if (v && typeof v === "object") walkGlob2(v);
+      }
+    };
+    var walkGlob = walkGlob2;
+    const targetLocal = defaultLocalName || "glob";
+    walkGlob2(parseResult.program);
+    if (defaultImportDecl) {
+      edits.push({
+        start: defaultImportDecl.start,
+        end: defaultImportDecl.end,
+        replacement: `import { globSync } from "glob";`
+      });
+    }
+  }
+  if (packageName === "mkdirp" && (diagnosticError.includes("sync") || diagnosticError.includes("mkdirpSync") || currentContent.includes("mkdirp.sync(") || defaultLocalName && currentContent.includes(`${defaultLocalName}.sync(`))) {
+    let walkMkdirp2 = function(node) {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === targetLocal && node.callee.property?.name === "sync") {
+        edits.push({
+          start: node.callee.start,
+          end: node.callee.end,
+          replacement: "mkdirpSync"
+        });
+      }
+      for (const k of Object.keys(node)) {
+        if (k === "parent") continue;
+        const v = node[k];
+        if (Array.isArray(v)) v.forEach(walkMkdirp2);
+        else if (v && typeof v === "object") walkMkdirp2(v);
+      }
+    };
+    var walkMkdirp = walkMkdirp2;
+    const targetLocal = defaultLocalName || "mkdirp";
+    walkMkdirp2(parseResult.program);
+    if (defaultImportDecl) {
+      edits.push({
+        start: defaultImportDecl.start,
+        end: defaultImportDecl.end,
+        replacement: `import { mkdirpSync } from "mkdirp";`
+      });
+    }
+  }
+  if (defaultImportDecl && defaultLocalName && (diagnosticError.includes("no default export") || diagnosticError.includes("has no exported member 'default'") || diagnosticError.includes("has no exported member default") || diagnosticError.includes("TS2614") || diagnosticError.includes("TS1192"))) {
+    edits.push({
+      start: defaultImportDecl.start,
+      end: defaultImportDecl.end,
+      replacement: `import * as ${defaultLocalName} from "${packageName}";`
+    });
   }
-  if (diagnosticError.includes("can only be used with a default import") || diagnosticError.includes("only be used with a default import") || diagnosticError.includes("TS1259")) {
-    const starImportRegex = new RegExp(
-      `import\\s+\\*\\s+as\\s+([a-zA-Z0-9_$]+)\\s+from\\s+['"]${escapeRegex(packageName)}['"]`,
-      "g"
-    );
-    if (starImportRegex.test(newContent)) {
-      newContent = newContent.replace(
-        starImportRegex,
-        `import $1 from "${packageName}"`
-      );
-      modified = true;
+  if (namespaceLocalName && (diagnosticError.includes("can only be used with a default import") || diagnosticError.includes("only be used with a default import") || diagnosticError.includes("TS1259"))) {
+    for (const statement of body) {
+      if (statement.type === "ImportDeclaration" && String(statement.source?.value) === packageName) {
+        edits.push({
+          start: statement.start,
+          end: statement.end,
+          replacement: `import ${namespaceLocalName} from "${packageName}";`
+        });
+      }
     }
   }
   const diagnostics = parseCompilerDiagnostics(diagnosticError);
   for (const diag of diagnostics) {
     if (diag.missingMember && diag.suggestedSymbol) {
-      const missingMember = diag.missingMember;
-      const suggestedSymbol = diag.suggestedSymbol;
-      if (filePath && diag.filePath && filePath.endsWith(diag.filePath) && diag.line && diag.line > 0) {
-        const fileLines = newContent.split("\n");
-        const idx = diag.line - 1;
-        if (idx >= 0 && idx < fileLines.length) {
-          const line = fileLines[idx];
-          const replaced = line.replace(new RegExp(`\\.${escapeRegex(missingMember)}\\b`, "g"), `.${suggestedSymbol}`).replace(new RegExp(`\\b${escapeRegex(missingMember)}\\b`, "g"), suggestedSymbol);
-          if (replaced !== line) {
-            fileLines[idx] = replaced;
-            newContent = fileLines.join("\n");
-            modified = true;
+      let getLine2 = function(offset) {
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low <= high) {
+          const mid = Math.floor((low + high) / 2);
+          if (lineStarts[mid] <= offset) {
+            if (mid === lineStarts.length - 1 || lineStarts[mid + 1] > offset) {
+              return mid + 1;
+            }
+            low = mid + 1;
+          } else {
+            high = mid - 1;
           }
         }
-      } else {
-        const memberRegex = new RegExp(`\\.${escapeRegex(missingMember)}\\b`, "g");
-        if (memberRegex.test(newContent)) {
-          newContent = newContent.replace(memberRegex, `.${suggestedSymbol}`);
-          modified = true;
+        return 1;
+      }, walkDiagnostics2 = function(node) {
+        if (!node || typeof node !== "object") return;
+        if (node.type === "MemberExpression" && node.property?.name === missing) {
+          const line = getLine2(node.start);
+          const lineMatches = !diag.line || diag.line === line;
+          if (lineMatches) {
+            edits.push({
+              start: node.property.start,
+              end: node.property.end,
+              replacement: suggested
+            });
+          }
         }
-        const importPattern = new RegExp(
-          `import\\s*\\{[^}]*\\b${escapeRegex(missingMember)}\\b[^}]*\\}\\s*from\\s*['"]${escapeRegex(packageName)}['"]`,
-          "g"
-        );
-        if (importPattern.test(newContent)) {
-          newContent = newContent.replace(
-            importPattern,
-            (match) => match.replace(new RegExp(`\\b${escapeRegex(missingMember)}\\b`, "g"), suggestedSymbol)
-          );
-          modified = true;
+        if (node.type === "ImportSpecifier" && (node.imported?.name === missing || node.local?.name === missing)) {
+          edits.push({
+            start: node.local.start,
+            end: node.local.end,
+            replacement: suggested
+          });
+        }
+        for (const k of Object.keys(node)) {
+          if (k === "parent") continue;
+          const v = node[k];
+          if (Array.isArray(v)) v.forEach(walkDiagnostics2);
+          else if (v && typeof v === "object") walkDiagnostics2(v);
         }
+      };
+      var getLine = getLine2, walkDiagnostics = walkDiagnostics2;
+      const missing = diag.missingMember;
+      const suggested = diag.suggestedSymbol;
+      const lineStarts = [0];
+      for (let i = 0; i < currentContent.length; i++) {
+        if (currentContent[i] === "\n") lineStarts.push(i + 1);
       }
+      walkDiagnostics2(parseResult.program);
     }
   }
-  const lineDiags = diagnostics.filter(
-    (d) => Boolean(filePath && d.filePath && filePath.endsWith(d.filePath) && typeof d.line === "number" && d.line > 0)
-  ).sort((a, b) => b.line - a.line);
-  const processedLines = /* @__PURE__ */ new Set();
-  for (const diag of lineDiags) {
-    if (processedLines.has(diag.line)) continue;
-    processedLines.add(diag.line);
-    const fileLines = newContent.split("\n");
-    const targetLineIdx = diag.line - 1;
-    if (targetLineIdx >= 0 && targetLineIdx < fileLines.length) {
-      const prevLine = targetLineIdx > 0 ? fileLines[targetLineIdx - 1] : "";
-      if (!prevLine?.includes("@ts-expect-error") && !fileLines[targetLineIdx]?.includes("@ts-expect-error")) {
-        const indent = fileLines[targetLineIdx]?.match(/^\s*/)?.[0] || "";
-        fileLines.splice(
-          targetLineIdx,
-          0,
-          `${indent}// @ts-expect-error [autoremediator-refactor]: breaking change in ${packageName}`
-        );
-        newContent = fileLines.join("\n");
-        modified = true;
-      }
+  if (edits.length > 0) {
+    currentContent = applyEdits(currentContent, edits);
+    modified = true;
+  }
+  if (argumentTransforms) {
+    const argResult = transformCallArguments(currentContent, {
+      ...argumentTransforms,
+      filePath
+    });
+    if (argResult.modified) {
+      currentContent = argResult.newContent;
+      modified = true;
     }
   }
-  return { modified, newContent };
+  return { modified, newContent: currentContent };
 }
 async function refactorConsumerCallSites(params) {
-  const { packageName, diagnosticError, callSites } = params;
+  const { packageName, diagnosticError, callSites, argumentTransforms } = params;
   if (callSites.length === 0) {
     return {
       applied: false,
@@ -3828,16 +4678,17 @@ async function refactorConsumerCallSites(params) {
   const refactoredFiles = [];
   try {
     for (const site of callSites) {
-      const originalContent = site.sourceContent || readFileSync12(site.filePath, "utf8");
+      const originalContent = site.sourceContent || readFileSync13(site.filePath, "utf8");
       snapshots[site.filePath] = originalContent;
       const { modified, newContent } = transformFileContent(
         originalContent,
         packageName,
         diagnosticError,
-        site.filePath
+        site.filePath,
+        argumentTransforms
       );
       if (modified && newContent !== originalContent) {
-        writeFileSync3(site.filePath, newContent, "utf8");
+        writeFileSync5(site.filePath, newContent, "utf8");
         refactoredFiles.push(site.filePath);
       }
     }
@@ -3860,7 +4711,7 @@ async function refactorConsumerCallSites(params) {
     return {
       applied: false,
       refactoredFiles: [],
-      snapshots: {},
+      snapshots,
       error: `Failed to apply breaking change refactoring: ${message}`
     };
   }
@@ -3883,7 +4734,13 @@ var applyVersionBumpTool = defineTool({
     installPreferOffline: z4.boolean().optional(),
     enforceFrozenLockfile: z4.boolean().optional(),
     workspace: z4.string().optional(),
-    breakingChangeRefactor: z4.boolean().optional().describe("If true, attempt agentic call-site refactoring when validation fails after major upgrade")
+    breakingChangeRefactor: z4.boolean().optional().describe(
+      "If true, attempt agentic call-site refactoring when validation fails after major upgrade"
+    ),
+    reproductionTest: z4.string().optional().describe("Optional reproduction test script verifying fix"),
+    proofOfFix: z4.union([z4.boolean(), z4.string()]).optional().describe("If true or script path/content, enforce dual-stage exploit reproduction"),
+    requireProofOfFix: z4.boolean().optional().describe("If true, fail and rollback version bump if proof-of-fix verification fails"),
+    patchesDir: z4.string().optional().default("./patches").describe("Directory containing patch/reproduction artifacts")
   }),
   execute: async ({
     cwd,
@@ -3899,10 +4756,14 @@ var applyVersionBumpTool = defineTool({
     installPreferOffline,
     enforceFrozenLockfile,
     workspace,
-    breakingChangeRefactor
+    breakingChangeRefactor,
+    reproductionTest,
+    proofOfFix,
+    requireProofOfFix,
+    patchesDir
   }) => {
     const pm = packageManager ?? detectPackageManager(cwd);
-    let pkgPath = join15(cwd, "package.json");
+    let pkgPath = join16(cwd, "package.json");
     const loadedPolicy = loadPolicy(cwd, policy);
     const commandConstraints = {
       ...loadedPolicy.constraints,
@@ -3924,7 +4785,7 @@ var applyVersionBumpTool = defineTool({
         message: `Policy blocked changes for package "${packageName}".`
       };
     }
-    const isMajorBump = semver3.valid(fromVersion) && semver3.valid(toVersion) && semver3.major(toVersion) > semver3.major(fromVersion);
+    const isMajorBump = semver4.valid(fromVersion) && semver4.valid(toVersion) && semver4.major(toVersion) > semver4.major(fromVersion);
     if (isMajorBump && !loadedPolicy.allowMajorBumps) {
       return {
         packageName,
@@ -3937,10 +4798,10 @@ var applyVersionBumpTool = defineTool({
         message: `Policy blocked major bump for "${packageName}" (${fromVersion} -> ${toVersion}).`
       };
     }
-    pkgPath = join15(cwd, "package.json");
+    pkgPath = join16(cwd, "package.json");
     let pkgJson;
     try {
-      pkgJson = JSON.parse(readFileSync13(pkgPath, "utf8"));
+      pkgJson = JSON.parse(readFileSync14(pkgPath, "utf8"));
     } catch {
       return {
         packageName,
@@ -4000,8 +4861,57 @@ var applyVersionBumpTool = defineTool({
       };
     }
     return withRepoLock(cwd, async () => {
+      const prepared = await prepareReproductionTestFile({
+        cwd,
+        packageName,
+        vulnerableVersion: fromVersion,
+        patchesDir,
+        proofOfFix,
+        reproductionTest
+      });
+      const reproTestPath = prepared.testFilePath;
+      const isProofActive = Boolean(reproTestPath || proofOfFix || requireProofOfFix);
+      let negativePhaseResult;
+      if (isProofActive) {
+        if (!reproTestPath) {
+          if (requireProofOfFix) {
+            return {
+              packageName,
+              strategy: "none",
+              fromVersion,
+              toVersion,
+              applied: false,
+              dryRun,
+              unresolvedReason: "policy-blocked",
+              message: "Proof-of-fix verification required, but no reproduction test or script was supplied."
+            };
+          }
+        } else {
+          negativePhaseResult = await runProofOfFixPhase({
+            stage: "negative",
+            testFilePath: reproTestPath,
+            cwd
+          });
+          if (!negativePhaseResult.passed) {
+            if (prepared.isCreated && reproTestPath) {
+              await rm3(reproTestPath, { force: true }).catch(() => {
+              });
+            }
+            return {
+              packageName,
+              strategy: "version-bump",
+              fromVersion,
+              toVersion,
+              applied: false,
+              dryRun: false,
+              unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+              message: `Proof-of-fix negative phase failed: ${negativePhaseResult.error}`
+            };
+          }
+        }
+      }
       pkgJson[depField][packageName] = newRange;
-      writeFileSync4(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+      writeFileSync6(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
       try {
         const [installCmd, ...installArgs] = effectiveInstallCommand;
         await safeExeca(installCmd, installArgs, {
@@ -4010,7 +4920,7 @@ var applyVersionBumpTool = defineTool({
         });
       } catch (err) {
         pkgJson[depField][packageName] = currentRange;
-        writeFileSync4(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+        writeFileSync6(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
         const message = err instanceof Error ? err.message : String(err);
         return {
           packageName,
@@ -4082,7 +4992,7 @@ var applyVersionBumpTool = defineTool({
       }
       if (!validationResult.passed) {
         pkgJson[depField][packageName] = currentRange;
-        writeFileSync4(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+        writeFileSync6(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
         try {
           const [rollbackCmd, ...rollbackArgs] = effectiveInstallCommand;
           await safeExeca(rollbackCmd, rollbackArgs, {
@@ -4104,6 +5014,49 @@ var applyVersionBumpTool = defineTool({
           message: `${prefix2} after upgrading "${packageName}" to ${toVersion}. Rolled back to ${currentRange}. Error: ${failureMessage}`
         };
       }
+      let proofOfFixVerification;
+      if (reproTestPath && negativePhaseResult?.passed) {
+        const positivePhaseResult = await runProofOfFixPhase({
+          stage: "positive",
+          testFilePath: reproTestPath,
+          cwd
+        });
+        if (!positivePhaseResult.passed) {
+          pkgJson[depField][packageName] = currentRange;
+          writeFileSync6(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+          try {
+            const [rollbackCmd, ...rollbackArgs] = effectiveInstallCommand;
+            await safeExeca(rollbackCmd, rollbackArgs, {
+              cwd,
+              stdio: "pipe"
+            });
+          } catch {
+          }
+          if (prepared.isCreated && reproTestPath) {
+            await rm3(reproTestPath, { force: true }).catch(() => {
+            });
+          }
+          return {
+            packageName,
+            strategy: "version-bump",
+            fromVersion,
+            toVersion,
+            applied: false,
+            dryRun: false,
+            unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+            message: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`
+          };
+        }
+        proofOfFixVerification = assembleProofOfFixVerification({
+          reproductionTestPath: reproTestPath,
+          negativePhase: negativePhaseResult,
+          positivePhase: positivePhaseResult,
+          regressionPhase: {
+            executed: runTests,
+            passed: validationResult.passed
+          }
+        });
+      }
       if (refactoredFilesList && refactoredFilesList.length > 0) {
         return {
           packageName,
@@ -4113,6 +5066,7 @@ var applyVersionBumpTool = defineTool({
           applied: true,
           dryRun: false,
           refactoredFiles: refactoredFilesList,
+          proofOfFix: proofOfFixVerification,
           message: `Upgraded "${packageName}" from ${fromVersion} to ${toVersion} and refactored ${refactoredFilesList.length} call-site file(s) across breaking API changes.`
         };
       }
@@ -4136,6 +5090,7 @@ var applyVersionBumpTool = defineTool({
         toVersion,
         applied: true,
         dryRun: false,
+        proofOfFix: proofOfFixVerification,
         message: `Successfully upgraded "${packageName}" from ${fromVersion} to ${toVersion} in ${depField}, then ran ${effectiveInstallCommand.join(" ")}${runTests ? ` and passed ${effectiveTestCommand.join(" ")}` : ""}.${dedupeNote}`
       };
     });
@@ -4144,117 +5099,10 @@ var applyVersionBumpTool = defineTool({
 
 // src/remediation/tools/apply-package-override/index.ts
 import { z as z5 } from "zod";
-import { join as join16 } from "path";
-import { existsSync as existsSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "fs";
-import semver4 from "semver";
-
-// src/remediation/tools/apply-package-override/helpers.ts
-async function collectDependencyTrace(cwd, pm, packageName, constraints) {
-  try {
-    const whyCommand = resolveWhyCommand(pm, packageName, constraints);
-    if (whyCommand.length === 0) return void 0;
-    const [whyCmd, ...whyArgs] = whyCommand;
-    const result = await safeExeca(whyCmd, whyArgs, {
-      cwd,
-      stdio: "pipe",
-      reject: false
-    });
-    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").split("\n").map((line) => line.trim()).filter(Boolean);
-    if (output.length === 0) return void 0;
-    return output.slice(0, 3).join(" | ");
-  } catch {
-    return void 0;
-  }
-}
-function describeOverrideField(packageManager) {
-  if (packageManager === "npm" || packageManager === "bun") return "overrides";
-  if (packageManager === "pnpm") return "pnpm.overrides";
-  if (packageManager === "deno") return "overrides";
-  return "resolutions";
-}
-function getOverrideValue(pkgJson, packageManager, packageName) {
-  if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno") {
-    return pkgJson.overrides?.[packageName];
-  }
-  if (packageManager === "pnpm") return pkgJson.pnpm?.overrides?.[packageName];
-  return pkgJson.resolutions?.[packageName];
-}
-function setOverrideValue(pkgJson, packageManager, packageName, version) {
-  if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno") {
-    pkgJson.overrides = { ...pkgJson.overrides, [packageName]: version };
-    return;
-  }
-  if (packageManager === "pnpm") {
-    pkgJson.pnpm = {
-      ...pkgJson.pnpm,
-      overrides: {
-        ...pkgJson.pnpm?.overrides,
-        [packageName]: version
-      }
-    };
-    return;
-  }
-  pkgJson.resolutions = { ...pkgJson.resolutions, [packageName]: version };
-}
-function restoreOverrideValue(pkgJson, packageManager, packageName, previousValue) {
-  if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno") {
-    pkgJson.overrides = restoreRecord(pkgJson.overrides, packageName, previousValue);
-    return;
-  }
-  if (packageManager === "pnpm") {
-    pkgJson.pnpm = {
-      ...pkgJson.pnpm,
-      overrides: restoreRecord(pkgJson.pnpm?.overrides, packageName, previousValue)
-    };
-    if (!pkgJson.pnpm.overrides) {
-      delete pkgJson.pnpm.overrides;
-    }
-    if (Object.keys(pkgJson.pnpm).length === 0) {
-      delete pkgJson.pnpm;
-    }
-    return;
-  }
-  pkgJson.resolutions = restoreRecord(pkgJson.resolutions, packageName, previousValue);
-}
-function getDenoJsonImportValue(denoJson, packageName) {
-  const imports = denoJson.imports ?? {};
-  if (imports[packageName] !== void 0) {
-    return { key: packageName, value: imports[packageName] };
-  }
-  const npmKey = `npm:${packageName}`;
-  if (imports[npmKey] !== void 0) {
-    return { key: npmKey, value: imports[npmKey] };
-  }
-  return void 0;
-}
-function setDenoJsonImportValue(denoJson, packageName, version) {
-  const existing = getDenoJsonImportValue(denoJson, packageName);
-  const key = existing?.key ?? `npm:${packageName}`;
-  denoJson.imports = { ...denoJson.imports, [key]: `npm:${packageName}@${version}` };
-}
-function restoreDenoJsonImportValue(denoJson, packageName, previousEntry) {
-  const existing = getDenoJsonImportValue(denoJson, packageName);
-  if (!existing) return;
-  const imports = { ...denoJson.imports };
-  if (previousEntry === void 0) {
-    delete imports[existing.key];
-  } else {
-    delete imports[existing.key];
-    imports[previousEntry.key] = previousEntry.value;
-  }
-  denoJson.imports = Object.keys(imports).length > 0 ? imports : void 0;
-}
-function restoreRecord(record, key, previousValue) {
-  const nextRecord = { ...record };
-  if (previousValue === void 0) {
-    delete nextRecord[key];
-  } else {
-    nextRecord[key] = previousValue;
-  }
-  return Object.keys(nextRecord).length > 0 ? nextRecord : void 0;
-}
-
-// src/remediation/tools/apply-package-override/index.ts
+import { join as join17 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
+import { rm as rm4 } from "fs/promises";
+import semver5 from "semver";
 var applyPackageOverrideTool = defineTool({
   description: "Apply a package-manager-native package.json override for a vulnerable transitive dependency and reinstall. Uses npm overrides, pnpm.overrides, yarn resolutions, bun overrides, or deno.json imports.",
   parameters: z5.object({
@@ -4270,7 +5118,11 @@ var applyPackageOverrideTool = defineTool({
     installMode: z5.enum(["standard", "prefer-offline", "deterministic"]).optional(),
     installPreferOffline: z5.boolean().optional(),
     enforceFrozenLockfile: z5.boolean().optional(),
-    workspace: z5.string().optional()
+    workspace: z5.string().optional(),
+    reproductionTest: z5.string().optional().describe("Optional reproduction test script verifying fix"),
+    proofOfFix: z5.union([z5.boolean(), z5.string()]).optional().describe("If true or script path/content, enforce dual-stage exploit reproduction"),
+    requireProofOfFix: z5.boolean().optional().describe("If true, fail and rollback override if proof-of-fix verification fails"),
+    patchesDir: z5.string().optional().default("./patches").describe("Directory containing patch/reproduction artifacts")
   }),
   execute: async ({
     cwd,
@@ -4285,12 +5137,16 @@ var applyPackageOverrideTool = defineTool({
     installMode,
     installPreferOffline,
     enforceFrozenLockfile,
-    workspace
+    workspace,
+    reproductionTest,
+    proofOfFix,
+    requireProofOfFix,
+    patchesDir
   }) => {
     const pm = packageManager ?? detectPackageManager(cwd);
-    const pkgPath = join16(cwd, "package.json");
-    const denoJsonPath = join16(cwd, "deno.json");
-    const isDenoNative = pm === "deno" && !existsSync12(pkgPath);
+    const pkgPath = join17(cwd, "package.json");
+    const denoJsonPath = join17(cwd, "deno.json");
+    const isDenoNative = pm === "deno" && !existsSync13(pkgPath);
     const loadedPolicy = loadPolicy(cwd, policy);
     const commandConstraints = {
       ...loadedPolicy.constraints,
@@ -4316,7 +5172,7 @@ var applyPackageOverrideTool = defineTool({
         message: `Policy blocked changes for package "${packageName}".`
       };
     }
-    const isMajorBump = semver4.valid(fromVersion) && semver4.valid(toVersion) && semver4.major(toVersion) > semver4.major(fromVersion);
+    const isMajorBump = semver5.valid(fromVersion) && semver5.valid(toVersion) && semver5.major(toVersion) > semver5.major(fromVersion);
     if (isMajorBump && !loadedPolicy.allowMajorBumps) {
       return {
         packageName,
@@ -4332,7 +5188,7 @@ var applyPackageOverrideTool = defineTool({
     if (isDenoNative) {
       let denoJson;
       try {
-        denoJson = JSON.parse(readFileSync14(denoJsonPath, "utf8"));
+        denoJson = JSON.parse(readFileSync15(denoJsonPath, "utf8"));
       } catch {
         return {
           packageName,
@@ -4377,14 +5233,63 @@ var applyPackageOverrideTool = defineTool({
         };
       }
       return withRepoLock(cwd, async () => {
+        const prepared = await prepareReproductionTestFile({
+          cwd,
+          packageName,
+          vulnerableVersion: fromVersion,
+          patchesDir,
+          proofOfFix,
+          reproductionTest
+        });
+        const reproTestPath = prepared.testFilePath;
+        const isProofActive = Boolean(reproTestPath || proofOfFix || requireProofOfFix);
+        let negativePhaseResult;
+        if (isProofActive) {
+          if (!reproTestPath) {
+            if (requireProofOfFix) {
+              return {
+                packageName,
+                strategy: "none",
+                fromVersion,
+                toVersion,
+                applied: false,
+                dryRun,
+                unresolvedReason: "policy-blocked",
+                message: "Proof-of-fix verification required, but no reproduction test or script was supplied."
+              };
+            }
+          } else {
+            negativePhaseResult = await runProofOfFixPhase({
+              stage: "negative",
+              testFilePath: reproTestPath,
+              cwd
+            });
+            if (!negativePhaseResult.passed) {
+              if (prepared.isCreated && reproTestPath) {
+                await rm4(reproTestPath, { force: true }).catch(() => {
+                });
+              }
+              return {
+                packageName,
+                strategy: "override",
+                fromVersion,
+                toVersion,
+                applied: false,
+                dryRun: false,
+                unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+                message: `Proof-of-fix negative phase failed: ${negativePhaseResult.error}`
+              };
+            }
+          }
+        }
         setDenoJsonImportValue(denoJson, overrideSelector, toVersion);
-        writeFileSync5(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
+        writeFileSync7(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
         try {
           const [installCmd, ...installArgs] = installCommand;
           await safeExeca(installCmd, installArgs, { cwd, stdio: "pipe" });
         } catch (err) {
           restoreDenoJsonImportValue(denoJson, overrideSelector, existingEntry);
-          writeFileSync5(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
+          writeFileSync7(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
           const message = err instanceof Error ? err.message : String(err);
           return {
             packageName,
@@ -4403,7 +5308,7 @@ var applyPackageOverrideTool = defineTool({
             await safeExeca(testCmd, testArgs, { cwd, stdio: "pipe" });
           } catch (err) {
             restoreDenoJsonImportValue(denoJson, overrideSelector, existingEntry);
-            writeFileSync5(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
+            writeFileSync7(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
             try {
               const [rollbackCmd, ...rollbackArgs] = installCommand;
               await safeExeca(rollbackCmd, rollbackArgs, { cwd, stdio: "pipe" });
@@ -4422,6 +5327,46 @@ var applyPackageOverrideTool = defineTool({
             };
           }
         }
+        let proofOfFixVerification;
+        if (reproTestPath && negativePhaseResult?.passed) {
+          const positivePhaseResult = await runProofOfFixPhase({
+            stage: "positive",
+            testFilePath: reproTestPath,
+            cwd
+          });
+          if (!positivePhaseResult.passed) {
+            restoreDenoJsonImportValue(denoJson, overrideSelector, existingEntry);
+            writeFileSync7(denoJsonPath, JSON.stringify(denoJson, null, 2) + "\n", "utf8");
+            try {
+              const [rollbackCmd, ...rollbackArgs] = installCommand;
+              await safeExeca(rollbackCmd, rollbackArgs, { cwd, stdio: "pipe" });
+            } catch {
+            }
+            if (prepared.isCreated && reproTestPath) {
+              await rm4(reproTestPath, { force: true }).catch(() => {
+              });
+            }
+            return {
+              packageName,
+              strategy: "override",
+              fromVersion,
+              toVersion,
+              applied: false,
+              dryRun: false,
+              unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+              message: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`
+            };
+          }
+          proofOfFixVerification = assembleProofOfFixVerification({
+            reproductionTestPath: reproTestPath,
+            negativePhase: negativePhaseResult,
+            positivePhase: positivePhaseResult,
+            regressionPhase: {
+              executed: runTests,
+              passed: true
+            }
+          });
+        }
         return {
           packageName,
           strategy: "override",
@@ -4429,13 +5374,14 @@ var applyPackageOverrideTool = defineTool({
           toVersion,
           applied: true,
           dryRun: false,
+          proofOfFix: proofOfFixVerification,
           message: `Successfully updated deno.json imports["${existingEntry.key}"] for "${overrideSelector}" from ${fromVersion} to ${toVersion}, then ran ${installCommand.join(" ")}${runTests ? ` and passed ${testCommand.join(" ")}` : ""}.${dependencyTraceSuffix2}`
         };
       });
     }
     let pkgJson;
     try {
-      pkgJson = JSON.parse(readFileSync14(pkgPath, "utf8"));
+      pkgJson = JSON.parse(readFileSync15(pkgPath, "utf8"));
     } catch {
       return {
         packageName,
@@ -4464,14 +5410,63 @@ var applyPackageOverrideTool = defineTool({
       };
     }
     return withRepoLock(cwd, async () => {
+      const prepared = await prepareReproductionTestFile({
+        cwd,
+        packageName,
+        vulnerableVersion: fromVersion,
+        patchesDir,
+        proofOfFix,
+        reproductionTest
+      });
+      const reproTestPath = prepared.testFilePath;
+      const isProofActive = Boolean(reproTestPath || proofOfFix || requireProofOfFix);
+      let negativePhaseResult;
+      if (isProofActive) {
+        if (!reproTestPath) {
+          if (requireProofOfFix) {
+            return {
+              packageName,
+              strategy: "none",
+              fromVersion,
+              toVersion,
+              applied: false,
+              dryRun,
+              unresolvedReason: "policy-blocked",
+              message: "Proof-of-fix verification required, but no reproduction test or script was supplied."
+            };
+          }
+        } else {
+          negativePhaseResult = await runProofOfFixPhase({
+            stage: "negative",
+            testFilePath: reproTestPath,
+            cwd
+          });
+          if (!negativePhaseResult.passed) {
+            if (prepared.isCreated && reproTestPath) {
+              await rm4(reproTestPath, { force: true }).catch(() => {
+              });
+            }
+            return {
+              packageName,
+              strategy: "override",
+              fromVersion,
+              toVersion,
+              applied: false,
+              dryRun: false,
+              unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+              message: `Proof-of-fix negative phase failed: ${negativePhaseResult.error}`
+            };
+          }
+        }
+      }
       setOverrideValue(pkgJson, pm, overrideSelector, toVersion);
-      writeFileSync5(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+      writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
       try {
         const [installCmd, ...installArgs] = installCommand;
         await safeExeca(installCmd, installArgs, { cwd, stdio: "pipe" });
       } catch (err) {
         restoreOverrideValue(pkgJson, pm, overrideSelector, previousValue);
-        writeFileSync5(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+        writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
         const message = err instanceof Error ? err.message : String(err);
         return {
           packageName,
@@ -4490,7 +5485,7 @@ var applyPackageOverrideTool = defineTool({
           await safeExeca(testCmd, testArgs, { cwd, stdio: "pipe" });
         } catch (err) {
           restoreOverrideValue(pkgJson, pm, overrideSelector, previousValue);
-          writeFileSync5(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+          writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
           try {
             const [rollbackCmd, ...rollbackArgs] = installCommand;
             await safeExeca(rollbackCmd, rollbackArgs, { cwd, stdio: "pipe" });
@@ -4509,6 +5504,46 @@ var applyPackageOverrideTool = defineTool({
           };
         }
       }
+      let proofOfFixVerification;
+      if (reproTestPath && negativePhaseResult?.passed) {
+        const positivePhaseResult = await runProofOfFixPhase({
+          stage: "positive",
+          testFilePath: reproTestPath,
+          cwd
+        });
+        if (!positivePhaseResult.passed) {
+          restoreOverrideValue(pkgJson, pm, overrideSelector, previousValue);
+          writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+          try {
+            const [rollbackCmd, ...rollbackArgs] = installCommand;
+            await safeExeca(rollbackCmd, rollbackArgs, { cwd, stdio: "pipe" });
+          } catch {
+          }
+          if (prepared.isCreated && reproTestPath) {
+            await rm4(reproTestPath, { force: true }).catch(() => {
+            });
+          }
+          return {
+            packageName,
+            strategy: "override",
+            fromVersion,
+            toVersion,
+            applied: false,
+            dryRun: false,
+            unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+            message: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`
+          };
+        }
+        proofOfFixVerification = assembleProofOfFixVerification({
+          reproductionTestPath: reproTestPath,
+          negativePhase: negativePhaseResult,
+          positivePhase: positivePhaseResult,
+          regressionPhase: {
+            executed: runTests,
+            passed: true
+          }
+        });
+      }
       let dedupeNote = "";
       if (dedupeCommand.length > 0) {
         try {
@@ -4526,6 +5561,7 @@ var applyPackageOverrideTool = defineTool({
         toVersion,
         applied: true,
         dryRun: false,
+        proofOfFix: proofOfFixVerification,
         message: `Successfully applied ${overrideLabel} for "${overrideSelector}" from ${fromVersion} to ${toVersion}, then ran ${installCommand.join(" ")}${runTests ? ` and passed ${testCommand.join(" ")}` : ""}.${dedupeNote}${dependencyTraceSuffix}`
       };
     });
@@ -4608,7 +5644,19 @@ async function verifyPackageTrust(packageName, targetVersion, policy) {
 
 // src/remediation/local/primary-strategy.ts
 async function resolvePrimaryResult(params) {
-  const { vulnerable, cwd, packageManager, dryRun, policy, runTests, constraints } = params;
+  const {
+    vulnerable,
+    cwd,
+    packageManager,
+    dryRun,
+    policy,
+    runTests,
+    constraints,
+    proofOfFix,
+    requireProofOfFix = constraints.requireProofOfFix,
+    reproductionTest,
+    patchesDir
+  } = params;
   const pkg = vulnerable.installed;
   const firstPatchedVersion = vulnerable.affected.firstPatchedVersion;
   if (pkg.type === "transitive") {
@@ -4708,7 +5756,11 @@ async function resolvePrimaryResult(params) {
       installMode: constraints.installMode,
       installPreferOffline: constraints.installPreferOffline,
       enforceFrozenLockfile: constraints.enforceFrozenLockfile,
-      workspace: constraints.workspace
+      workspace: constraints.workspace,
+      proofOfFix,
+      requireProofOfFix,
+      reproductionTest,
+      patchesDir
     });
     return {
       steps: 2,
@@ -4785,7 +5837,11 @@ async function resolvePrimaryResult(params) {
     installPreferOffline: constraints.installPreferOffline,
     enforceFrozenLockfile: constraints.enforceFrozenLockfile,
     workspace: constraints.workspace,
-    breakingChangeRefactor: constraints.enableBreakingChangeRefactor
+    breakingChangeRefactor: constraints.enableBreakingChangeRefactor,
+    proofOfFix,
+    requireProofOfFix,
+    reproductionTest,
+    patchesDir
   });
   return {
     steps: 2,
@@ -4795,10 +5851,10 @@ async function resolvePrimaryResult(params) {
 
 // src/remediation/tools/fetch-package-source.ts
 import { z as z6 } from "zod";
-import { mkdir as mkdir2, mkdtemp, readdir as readdir2, readFile as readFile4, rm as rm3 } from "fs/promises";
-import { join as join17 } from "path";
+import { mkdir as mkdir3, mkdtemp, readdir as readdir2, readFile as readFile4, rm as rm5 } from "fs/promises";
+import { join as join18 } from "path";
 import { tmpdir } from "os";
-import { execa as execa7 } from "execa";
+import { execa as execa6 } from "execa";
 var fetchPackageSourceTool = defineTool({
   description: "Download package tarball from npm and extract source files for CVE analysis. Supports custom file patterns (default: *.js, *.ts).",
   parameters: z6.object({
@@ -4816,34 +5872,33 @@ var fetchPackageSourceTool = defineTool({
     if (safePatterns.length === 0) {
       return { success: false, error: "No valid file patterns provided." };
     }
-    const tempBaseDir = await mkdtemp(join17(tmpdir(), "autoremediator-pkg-"));
-    const extractDir = join17(tempBaseDir, "out");
+    const tempBaseDir = await mkdtemp(join18(tmpdir(), "autoremediator-pkg-"));
+    const extractDir = join18(tempBaseDir, "out");
     try {
       const scopedName = packageName.split("/").pop();
       const npmUrl = `https://registry.npmjs.org/${packageName}/-/${scopedName}-${version}.tgz`;
-      await mkdir2(tempBaseDir, { recursive: true });
-      const tarballPath = join17(tempBaseDir, "package.tgz");
-      await execa7("curl", ["-L", "-o", tarballPath, npmUrl]);
-      await mkdir2(extractDir, { recursive: true });
-      await execa7("tar", ["-xzf", tarballPath, "-C", extractDir]);
+      await mkdir3(tempBaseDir, { recursive: true });
+      const tarballPath = join18(tempBaseDir, "package.tgz");
+      await execa6("curl", ["-f", "-s", "-S", "-L", "-o", tarballPath, npmUrl]);
+      await mkdir3(extractDir, { recursive: true });
+      await execa6("tar", ["-xzf", tarballPath, "-C", extractDir]);
       const extractedContents = await readdir2(extractDir);
-      const packageRootDir = extractedContents.includes("package") ? join17(extractDir, "package") : extractDir;
+      const packageRootDir = extractedContents.includes("package") ? join18(extractDir, "package") : extractDir;
       const sourceCode = {};
       async function walkDir(dir, relativeBase) {
         try {
           const files = await readdir2(dir, { withFileTypes: true });
           for (const file of files) {
-            const fullPath = join17(dir, file.name);
-            const relPath = join17(relativeBase, file.name);
+            const fullPath = join18(dir, file.name);
+            const relPath = join18(relativeBase, file.name);
             if (file.isDirectory()) {
-              if (!["node_modules", ".git", "dist", "build", "coverage", ".next", "out"].includes(
-                file.name
-              )) {
+              if (!["node_modules", ".git", "coverage", ".next"].includes(file.name)) {
                 await walkDir(fullPath, relPath);
               }
             } else if (file.isFile()) {
               const matches = safePatterns.some((pattern) => {
-                const regex = new RegExp(`^${pattern.replace(/\*/g, ".*").replace(/\./g, "\\.")}$`);
+                const escaped = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
+                const regex = new RegExp(`^${escaped}$`);
                 return regex.test(file.name);
               });
               if (matches) {
@@ -4872,7 +5927,8 @@ var fetchPackageSourceTool = defineTool({
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      if (message.includes("404") || message.includes("not found")) {
+      const exitCode = typeof err.exitCode === "number" ? err.exitCode : void 0;
+      if (exitCode === 22 || message.includes("404") || message.includes("not found") || message.includes("returned error: 404")) {
         return {
           success: false,
           error: `Package ${packageName}@${version} not found on npm registry. It may not exist or the version may be incorrect.`
@@ -4883,7 +5939,7 @@ var fetchPackageSourceTool = defineTool({
         error: `Failed to fetch and extract package ${packageName}@${version}: ${message}`
       };
     } finally {
-      await rm3(tempBaseDir, { recursive: true, force: true });
+      await rm5(tempBaseDir, { recursive: true, force: true });
     }
   }
 });
@@ -4964,7 +6020,7 @@ Important:
 }
 
 // src/remediation/tools/generate-patch/helpers.ts
-import { parseSync as parseSync3 } from "oxc-parser";
+import { parseSync as parseSync4 } from "oxc-parser";
 import YAML from "yaml";
 function parseLlmAnalysisResponse(text) {
   try {
@@ -4987,7 +6043,7 @@ function validatePatchedCodeSyntax(filePath, code) {
   const lowerPath = filePath.toLowerCase();
   if (/\.[cm]?[jt]sx?$/i.test(lowerPath)) {
     try {
-      const res = parseSync3(filePath, code);
+      const res = parseSync4(filePath, code);
       if (res.errors && res.errors.length > 0) {
         const errorMsg = res.errors.map((e) => e.message).join("; ");
         return {
@@ -5039,32 +6095,179 @@ function buildGeneratedPatches(sourceFiles, fixedCodeByFile) {
   }
   return patches;
 }
-function generateUnifiedDiff(original, fixed, filePath) {
+function splitLines(text) {
+  if (text.length === 0) return [];
+  const lines = text.split(/\r?\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function myersDiff(aLines, bLines) {
+  const N = aLines.length;
+  const M = bLines.length;
+  const max = N + M;
+  if (max === 0) return [];
+  const offset = max;
+  const v = new Int32Array(2 * max + 1);
+  const history = [];
+  v[offset + 1] = 0;
+  let dFound = -1;
+  for (let d = 0; d <= max; d++) {
+    const vCopy = new Int32Array(v);
+    history.push(vCopy);
+    for (let k = -d; k <= d; k += 2) {
+      let x2;
+      if (k === -d || k !== d && v[offset + k - 1] < v[offset + k + 1]) {
+        x2 = v[offset + k + 1];
+      } else {
+        x2 = v[offset + k - 1] + 1;
+      }
+      let y2 = x2 - k;
+      while (x2 < N && y2 < M && aLines[x2] === bLines[y2]) {
+        x2++;
+        y2++;
+      }
+      v[offset + k] = x2;
+      if (x2 >= N && y2 >= M) {
+        dFound = d;
+        break;
+      }
+    }
+    if (dFound !== -1) break;
+  }
+  let x = N;
+  let y = M;
+  const edits = [];
+  for (let d = dFound; d > 0; d--) {
+    const k = x - y;
+    const vPrev = history[d];
+    let prevK;
+    if (k === -d || k !== d && vPrev[offset + k - 1] < vPrev[offset + k + 1]) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevX = vPrev[offset + prevK];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      edits.push({ type: "common", text: aLines[x - 1] });
+      x--;
+      y--;
+    }
+    if (x === prevX) {
+      edits.push({ type: "insert", text: bLines[y - 1] });
+      y--;
+    } else {
+      edits.push({ type: "delete", text: aLines[x - 1] });
+      x--;
+    }
+  }
+  while (x > 0 && y > 0) {
+    edits.push({ type: "common", text: aLines[x - 1] });
+    x--;
+    y--;
+  }
+  edits.reverse();
+  return edits;
+}
+function generateUnifiedDiff(original, fixed, filePath, context = 3) {
   if (original === fixed) {
     return null;
   }
-  const originalLines = original.split("\n");
-  const fixedLines = fixed.split("\n");
-  const diff = [];
-  diff.push(`--- a/${filePath}`);
-  diff.push(`+++ b/${filePath}`);
-  diff.push(`@@ -1,${originalLines.length} +1,${fixedLines.length} @@`);
-  const maxLen = Math.max(originalLines.length, fixedLines.length);
-  for (let i = 0; i < maxLen; i++) {
-    const origLine = originalLines[i] || "";
-    const fixedLine = fixedLines[i] || "";
-    if (origLine !== fixedLine) {
-      if (origLine) {
-        diff.push(`-${origLine}`);
-      }
-      if (fixedLine) {
-        diff.push(`+${fixedLine}`);
-      }
-    } else if (origLine) {
-      diff.push(` ${origLine}`);
+  const aLines = splitLines(original);
+  const bLines = splitLines(fixed);
+  let prefixCount = 0;
+  while (prefixCount < aLines.length && prefixCount < bLines.length && aLines[prefixCount] === bLines[prefixCount]) {
+    prefixCount++;
+  }
+  let suffixCount = 0;
+  while (suffixCount < aLines.length - prefixCount && suffixCount < bLines.length - prefixCount && aLines[aLines.length - 1 - suffixCount] === bLines[bLines.length - 1 - suffixCount]) {
+    suffixCount++;
+  }
+  const prefixEdits = [];
+  for (let i = 0; i < prefixCount; i++) {
+    prefixEdits.push({ type: "common", text: aLines[i] });
+  }
+  const suffixEdits = [];
+  for (let i = aLines.length - suffixCount; i < aLines.length; i++) {
+    suffixEdits.push({ type: "common", text: aLines[i] });
+  }
+  const aMiddle = aLines.slice(prefixCount, aLines.length - suffixCount);
+  const bMiddle = bLines.slice(prefixCount, bLines.length - suffixCount);
+  const middleEdits = myersDiff(aMiddle, bMiddle);
+  const edits = [...prefixEdits, ...middleEdits, ...suffixEdits];
+  const changeIndices = [];
+  for (let i = 0; i < edits.length; i++) {
+    if (edits[i].type !== "common") {
+      changeIndices.push(i);
+    }
+  }
+  if (changeIndices.length === 0) {
+    return null;
+  }
+  const groups = [];
+  let currentGroup = [changeIndices[0]];
+  for (let i = 1; i < changeIndices.length; i++) {
+    const prev = changeIndices[i - 1];
+    const curr = changeIndices[i];
+    if (curr - prev - 1 <= 2 * context) {
+      currentGroup.push(curr);
+    } else {
+      groups.push(currentGroup);
+      currentGroup = [curr];
     }
   }
-  return diff.join("\n");
+  groups.push(currentGroup);
+  const hunkStrings = [];
+  for (const group of groups) {
+    const firstChange = group[0];
+    const lastChange = group[group.length - 1];
+    const startIndex = Math.max(0, firstChange - context);
+    const endIndex = Math.min(edits.length, lastChange + context + 1);
+    const hunkEdits = edits.slice(startIndex, endIndex);
+    let curOrig = 1;
+    let curFixed = 1;
+    for (let i = 0; i < startIndex; i++) {
+      if (edits[i].type === "common") {
+        curOrig++;
+        curFixed++;
+      } else if (edits[i].type === "delete") {
+        curOrig++;
+      } else if (edits[i].type === "insert") {
+        curFixed++;
+      }
+    }
+    let origStart = curOrig;
+    let fixedStart = curFixed;
+    let origCount = 0;
+    let fixedCount = 0;
+    for (const edit of hunkEdits) {
+      if (edit.type === "common") {
+        origCount++;
+        fixedCount++;
+      } else if (edit.type === "delete") {
+        origCount++;
+      } else if (edit.type === "insert") {
+        fixedCount++;
+      }
+    }
+    if (origCount === 0) origStart = Math.max(0, origStart - 1);
+    if (fixedCount === 0) fixedStart = Math.max(0, fixedStart - 1);
+    const lines = [];
+    lines.push(`@@ -${origStart},${origCount} +${fixedStart},${fixedCount} @@`);
+    for (const edit of hunkEdits) {
+      if (edit.type === "common") {
+        lines.push(` ${edit.text}`);
+      } else if (edit.type === "delete") {
+        lines.push(`-${edit.text}`);
+      } else if (edit.type === "insert") {
+        lines.push(`+${edit.text}`);
+      }
+    }
+    hunkStrings.push(lines.join("\n"));
+  }
+  return [`--- a/${filePath}`, `+++ b/${filePath}`, ...hunkStrings].join("\n") + "\n";
 }
 
 // src/remediation/tools/generate-patch/index.ts
@@ -5258,126 +6461,209 @@ var generatePatchTool = defineTool({
 
 // src/remediation/tools/apply-patch-file/index.ts
 import { z as z8 } from "zod";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import { isAbsolute as isAbsolute4, join as join19 } from "path";
-import { execa as execa9 } from "execa";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { join as join21 } from "path";
+import { execa as execa8 } from "execa";
 
-// src/remediation/proof-of-fix/runner.ts
-async function runProofOfFixPhase(options) {
-  const { stage, testFilePath, cwd, timeoutMs = 15e3 } = options;
-  const started = Date.now();
-  const isTs = testFilePath.endsWith(".ts");
-  const nodeArgs = isTs ? ["--experimental-strip-types", testFilePath] : [testFilePath];
+// src/platform/rollback.ts
+import { execFileSync, execSync } from "child_process";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync16, rmSync, statSync as statSync4, writeFileSync as writeFileSync8 } from "fs";
+import { isAbsolute as isAbsolute4, join as join19, relative as relative2 } from "path";
+var MANIFEST_PATTERNS = [
+  /package\.json$/,
+  /.*lock.*/,
+  /deno\.jsonc?$/,
+  /\.patch$/,
+  /\.autoremediator\.ya?ml$/,
+  /tsconfig.*\.json$/
+];
+var IGNORED_DIRS3 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".pnpm-store"]);
+var activeSnapshots = /* @__PURE__ */ new Set();
+function recordFileTouch(filePath) {
+  for (const snapshot of activeSnapshots) {
+    const absPath = isAbsolute4(filePath) ? filePath : join19(snapshot.cwd, filePath);
+    if (!absPath.startsWith(snapshot.cwd)) continue;
+    const relPath = relative2(snapshot.cwd, absPath);
+    if (!snapshot.fileSnapshots.has(relPath)) {
+      if (existsSync14(absPath)) {
+        try {
+          snapshot.fileSnapshots.set(relPath, readFileSync16(absPath, "utf8"));
+        } catch {
+          try {
+            snapshot.fileSnapshots.set(relPath, readFileSync16(absPath).toString("base64"));
+          } catch {
+            snapshot.fileSnapshots.set(relPath, null);
+          }
+        }
+      } else {
+        snapshot.fileSnapshots.set(relPath, null);
+      }
+    }
+  }
+}
+function discoverProjectFiles(dir, maxDepth = 4, currentDepth = 0) {
+  const discovered = [];
+  if (currentDepth > maxDepth) return discovered;
+  let entries;
   try {
-    const result = await safeExeca("node", nodeArgs, {
+    entries = readdirSync4(dir);
+  } catch {
+    return discovered;
+  }
+  for (const entry of entries) {
+    if (IGNORED_DIRS3.has(entry)) continue;
+    const fullPath = join19(dir, entry);
+    let stat2;
+    try {
+      stat2 = statSync4(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat2.isDirectory()) {
+      discovered.push(...discoverProjectFiles(fullPath, maxDepth, currentDepth + 1));
+    } else if (stat2.isFile()) {
+      const matchesPattern = MANIFEST_PATTERNS.some((pattern) => pattern.test(entry));
+      if (matchesPattern) {
+        discovered.push(fullPath);
+      }
+    }
+  }
+  return discovered;
+}
+async function isGitRepository(cwd) {
+  try {
+    const res = await safeExeca("git", ["rev-parse", "--is-inside-work-tree"], {
       cwd,
-      timeoutMs,
       stdio: "pipe"
     });
-    const durationMs = Date.now() - started;
-    const output = `${result.stdout || ""}
-${result.stderr || ""}`.trim();
-    if (stage === "negative") {
-      return {
-        executed: true,
-        passed: false,
-        exitCode: 0,
-        output,
-        durationMs,
-        error: "Exploit reproduction test passed on vulnerable target (failed to reproduce vulnerability)."
-      };
+    return String(res.stdout).trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function parsePorcelainLines(stdout) {
+  return stdout.split(/\r?\n/).map((l) => l.replace(/\r$/, "")).filter((l) => l.length >= 3 && l.slice(0, 2).trim().length > 0);
+}
+function parseGitPorcelainLine(line) {
+  if (!line || line.length < 3) return null;
+  const statusCode = line.slice(0, 2).trim();
+  let filePath = line.slice(3).trim();
+  if (filePath.includes(" -> ")) {
+    filePath = filePath.split(" -> ").pop().trim();
+  }
+  if (filePath.startsWith('"') && filePath.endsWith('"')) {
+    filePath = filePath.slice(1, -1).replace(/\\"/g, '"');
+  }
+  return { statusCode, filePath };
+}
+async function getGitStatusPorcelain(cwd) {
+  try {
+    const res = await safeExeca("git", ["status", "--porcelain=v1", "-uall"], {
+      cwd,
+      stdio: "pipe"
+    });
+    return parsePorcelainLines(String(res.stdout));
+  } catch {
+    return [];
+  }
+}
+async function createProjectSnapshot(cwd, explicitFiles) {
+  const isGit = await isGitRepository(cwd);
+  const gitStatusBefore = isGit ? await getGitStatusPorcelain(cwd) : void 0;
+  const fileSnapshots = /* @__PURE__ */ new Map();
+  const targetFiles = explicitFiles ? explicitFiles.map((f) => f.startsWith(cwd) ? f : join19(cwd, f)) : discoverProjectFiles(cwd);
+  for (const fullPath of targetFiles) {
+    const relPath = relative2(cwd, fullPath);
+    if (existsSync14(fullPath)) {
+      try {
+        fileSnapshots.set(relPath, readFileSync16(fullPath, "utf8"));
+      } catch {
+        try {
+          fileSnapshots.set(relPath, readFileSync16(fullPath).toString("base64"));
+        } catch {
+        }
+      }
+    } else {
+      fileSnapshots.set(relPath, null);
     }
-    return {
-      executed: true,
-      passed: true,
-      exitCode: 0,
-      output,
-      durationMs
-    };
-  } catch (err) {
-    const durationMs = Date.now() - started;
-    const execaErr = err;
-    const exitCode = typeof execaErr.exitCode === "number" ? execaErr.exitCode : 1;
-    const errorMsg = execaErr.message || String(err);
-    const output = [execaErr.stdout, execaErr.stderr, errorMsg].filter(Boolean).join("\n").trim();
-    if (stage === "negative") {
-      if (execaErr.timedOut || errorMsg.includes("timed out")) {
-        return {
-          executed: true,
-          passed: false,
-          exitCode,
-          output,
-          durationMs,
-          error: "Exploit reproduction test timed out (execution hung)."
-        };
+  }
+  const snapshot = {
+    cwd,
+    isGit,
+    gitStatusBefore,
+    fileSnapshots
+  };
+  return snapshot;
+}
+function restoreProjectSnapshotSync(snapshot) {
+  for (const [relPath, previousContent] of snapshot.fileSnapshots.entries()) {
+    const fullPath = join19(snapshot.cwd, relPath);
+    if (previousContent === null) {
+      if (existsSync14(fullPath)) {
+        try {
+          rmSync(fullPath, { force: true, recursive: true });
+        } catch {
+        }
       }
-      const isHarnessFailure = exitCode === 127 || errorMsg.includes("ENOENT") || output.includes("bad option:") || output.includes("Cannot find module") && output.includes(testFilePath);
-      if (isHarnessFailure) {
-        return {
-          executed: false,
-          passed: false,
-          exitCode,
-          output,
-          durationMs,
-          error: `Reproduction test failed to execute (harness error): ${errorMsg}`
-        };
+    } else {
+      try {
+        writeFileSync8(fullPath, previousContent, "utf8");
+      } catch {
       }
-      return {
-        executed: true,
-        passed: true,
-        exitCode,
-        output,
-        durationMs
-      };
     }
-    return {
-      executed: true,
-      passed: false,
-      exitCode,
-      output,
-      durationMs,
-      error: `Reproduction test failed on patched target: ${errorMsg}`
-    };
   }
-}
-function assembleProofOfFixVerification(params) {
-  const { reproductionTestPath, negativePhase, positivePhase, regressionPhase } = params;
-  const regPhase = regressionPhase ?? {
-    executed: false,
-    passed: true
-  };
-  let status = "verified";
-  let failureReason;
-  if (!negativePhase.passed) {
-    status = "failed";
-    failureReason = negativePhase.error || "negative-phase-failed";
-  } else if (!positivePhase.passed) {
-    status = "failed";
-    failureReason = positivePhase.error || "positive-phase-failed";
-  } else if (regPhase.executed && !regPhase.passed) {
-    status = "failed";
-    failureReason = regPhase.error || "regression-phase-failed";
+  const currentFiles = discoverProjectFiles(snapshot.cwd);
+  for (const fullPath of currentFiles) {
+    const relPath = relative2(snapshot.cwd, fullPath);
+    if (!snapshot.fileSnapshots.has(relPath)) {
+      try {
+        rmSync(fullPath, { force: true, recursive: true });
+      } catch {
+      }
+    }
+  }
+  if (snapshot.isGit) {
+    try {
+      const stdout = execSync("git status --porcelain=v1 -uall", {
+        cwd: snapshot.cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+        encoding: "utf8"
+      });
+      const currentStatus = parsePorcelainLines(stdout);
+      const beforeSet = new Set(snapshot.gitStatusBefore ?? []);
+      for (const line of currentStatus) {
+        if (beforeSet.has(line)) continue;
+        const parsed = parseGitPorcelainLine(line);
+        if (!parsed) continue;
+        const { statusCode, filePath } = parsed;
+        const fullPath = join19(snapshot.cwd, filePath);
+        if (statusCode === "??" && existsSync14(fullPath)) {
+          try {
+            rmSync(fullPath, { force: true, recursive: true });
+          } catch {
+          }
+        } else if (statusCode === "M" || statusCode === "MM" || statusCode === "D" || statusCode.includes("M") || statusCode.includes("D") || statusCode.includes("T")) {
+          try {
+            execFileSync("git", ["checkout", "--", filePath], {
+              cwd: snapshot.cwd,
+              stdio: "ignore"
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
   }
-  const durationMs = (negativePhase.durationMs || 0) + (positivePhase.durationMs || 0) + (regPhase.durationMs || 0);
-  return {
-    status,
-    reproductionTestPath,
-    negativePhase,
-    positivePhase,
-    regressionPhase: regPhase,
-    durationMs,
-    failureReason
-  };
 }
 
 // src/remediation/tools/apply-patch-file/helpers.ts
-import { existsSync as existsSync13 } from "fs";
-import { mkdtemp as mkdtemp2, readFile as readFile5, rm as rm4, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import { mkdtemp as mkdtemp2, readFile as readFile5, rm as rm6, writeFile as writeFile3 } from "fs/promises";
 import { createHash } from "crypto";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join18 } from "path";
-import { execa as execa8 } from "execa";
+import { join as join20 } from "path";
+import { execa as execa7 } from "execa";
 async function resolvePatchMode(packageManager, cwd) {
   if (packageManager === "npm" || packageManager === "bun" || packageManager === "deno")
     return "patch-package";
@@ -5408,10 +6694,10 @@ function computePatchIntegrity(patchContent) {
   return `sha256:${hex}`;
 }
 async function writePatchManifest(manifestFilePath, artifact) {
-  await writeFile2(manifestFilePath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  await writeFile3(manifestFilePath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
 }
 async function configurePatchPackagePostinstall(cwd, packageManager) {
-  const pkgJsonPath = join18(cwd, "package.json");
+  const pkgJsonPath = join20(cwd, "package.json");
   let pkgJson;
   try {
     pkgJson = JSON.parse(await readFile5(pkgJsonPath, "utf8"));
@@ -5426,7 +6712,7 @@ async function configurePatchPackagePostinstall(cwd, packageManager) {
     try {
       const commands = getPackageManagerCommands(packageManager);
       const [cmd, ...args] = commands.installDev("patch-package");
-      await execa8(cmd, args, {
+      await execa7(cmd, args, {
         cwd,
         stdio: "pipe"
       });
@@ -5447,11 +6733,11 @@ async function configurePatchPackagePostinstall(cwd, packageManager) {
   } else if (!currentPostinstall) {
     pkgJson.scripts.postinstall = patchApplyCmd;
   }
-  await writeFile2(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+  await writeFile3(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
   return { success: true };
 }
 async function capturePackageJsonSnapshot(cwd) {
-  const path = join18(cwd, "package.json");
+  const path = join20(cwd, "package.json");
   try {
     const content = await readFile5(path, "utf8");
     return { path, content };
@@ -5469,19 +6755,19 @@ async function cleanupPatchArtifacts(params) {
     installCommand,
     rerunInstall
   } = params;
-  await rm4(patchFilePath, { force: true }).catch(() => void 0);
+  await rm6(patchFilePath, { force: true }).catch(() => void 0);
   if (manifestFilePath) {
-    await rm4(manifestFilePath, { force: true }).catch(() => void 0);
+    await rm6(manifestFilePath, { force: true }).catch(() => void 0);
   }
   if (patchMode === "patch-package" && packageJsonSnapshot) {
-    await writeFile2(packageJsonSnapshot.path, packageJsonSnapshot.content, "utf8").catch(
+    await writeFile3(packageJsonSnapshot.path, packageJsonSnapshot.content, "utf8").catch(
       () => void 0
     );
   }
   if (!rerunInstall) return;
   try {
     const [installCmd, ...installArgs] = installCommand;
-    await execa8(installCmd, installArgs, {
+    await execa7(installCmd, installArgs, {
       cwd,
       stdio: "pipe"
     });
@@ -5495,7 +6781,7 @@ async function applyNativePatch(params) {
   const createArgs = ["patch", packageSpec];
   let patchDir;
   try {
-    const createResult = await execa8(createCommand, createArgs, {
+    const createResult = await execa7(createCommand, createArgs, {
       cwd,
       stdio: "pipe"
     });
@@ -5523,17 +6809,17 @@ ${createResult.stderr}`);
       error: `Could not determine native patch directory for ${packageSpec}.`
     };
   }
-  const tempPatchDir = await mkdtemp2(join18(tmpdir2(), "autoremediator-native-patch-"));
-  const tempPatchFile = join18(tempPatchDir, "change.patch");
+  const tempPatchDir = await mkdtemp2(join20(tmpdir2(), "autoremediator-native-patch-"));
+  const tempPatchFile = join20(tempPatchDir, "change.patch");
   try {
-    await writeFile2(tempPatchFile, patchContent, "utf8");
-    await execa8("patch", ["-p1", "-i", tempPatchFile], {
+    await writeFile3(tempPatchFile, patchContent, "utf8");
+    await execa7("patch", ["-p1", "-i", tempPatchFile], {
       cwd: patchDir,
       stdio: "pipe"
     });
     const commitCommand = patchMode === "native-pnpm" ? "pnpm" : "yarn";
     const commitArgs = patchMode === "native-pnpm" ? ["patch-commit", patchDir] : ["patch-commit", "-s", patchDir];
-    await execa8(commitCommand, commitArgs, {
+    await execa7(commitCommand, commitArgs, {
       cwd,
       stdio: "pipe"
     });
@@ -5548,19 +6834,19 @@ ${createResult.stderr}`);
       error: `Failed to apply native patch for ${packageSpec}: ${err instanceof Error ? err.message : String(err)}`
     };
   } finally {
-    await rm4(tempPatchDir, { recursive: true, force: true });
+    await rm6(tempPatchDir, { recursive: true, force: true });
   }
   return { success: true };
 }
 function extractPatchDirectory(output) {
   const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   for (const line of lines) {
-    if (existsSync13(line)) {
+    if (existsSync15(line)) {
       return line;
     }
     const tokens = line.split(/\s+/).map((token) => token.replace(/^['"]|['"]$/g, ""));
     for (const token of tokens) {
-      if (token.startsWith("/") && existsSync13(token)) {
+      if (token.startsWith("/") && existsSync15(token)) {
         return token;
       }
     }
@@ -5570,7 +6856,7 @@ function extractPatchDirectory(output) {
 async function validatePatchWithTests(cwd, testCommand) {
   try {
     const [cmd, ...args] = testCommand;
-    const result = await execa8(cmd, args, {
+    const result = await execa7(cmd, args, {
       cwd,
       timeout: 6e4,
       stdio: "pipe"
@@ -5664,6 +6950,18 @@ var applyPatchFileTool = defineTool({
     try {
       const pm = packageManager ?? detectPackageManager(cwd);
       const loadedPolicy = loadPolicy(cwd, policy);
+      if (!isPackageAllowed(loadedPolicy, packageName)) {
+        return {
+          success: false,
+          packageName,
+          vulnerableVersion,
+          applied: false,
+          dryRun,
+          unresolvedReason: "policy-blocked",
+          message: `Policy denyPackages blocked changes for package "${packageName}".`,
+          error: `Policy denyPackages blocked changes for package "${packageName}".`
+        };
+      }
       const commandConstraints = {
         ...loadedPolicy.constraints,
         installMode: installMode ?? loadedPolicy.constraints?.installMode,
@@ -5709,7 +7007,7 @@ var applyPatchFileTool = defineTool({
         };
       }
       const patchFileName = buildPatchFileName(packageName, vulnerableVersion);
-      const patchFilePath = join19(cwd, patchesDir, patchFileName);
+      const patchFilePath = join21(cwd, patchesDir, patchFileName);
       const manifestFilePath = `${patchFilePath}.json`;
       const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
       const baseArtifact = {
@@ -5748,9 +7046,11 @@ var applyPatchFileTool = defineTool({
       }
       return withRepoLock(cwd, async () => {
         const packageJsonSnapshot = patchModeRequiresPackageJsonSnapshot(pm) ? await capturePackageJsonSnapshot(cwd) : void 0;
-        const patchesDirPath = join19(cwd, patchesDir);
-        await mkdir3(patchesDirPath, { recursive: true });
-        await writeFile3(patchFilePath, selectedPatch, "utf8");
+        const patchesDirPath = join21(cwd, patchesDir);
+        await mkdir4(patchesDirPath, { recursive: true });
+        recordFileTouch(patchFilePath);
+        recordFileTouch(manifestFilePath);
+        await writeFile4(patchFilePath, selectedPatch, "utf8");
         validationPhases.push({
           phase: "patch-write",
           passed: true,
@@ -5773,21 +7073,19 @@ var applyPatchFileTool = defineTool({
         await writePatchManifest(manifestFilePath, artifact);
         let reproductionTestPath;
         let negativePhaseResult;
-        if (typeof proofOfFix === "string" && proofOfFix.trim().length > 0) {
-          const resolvedPath = isAbsolute4(proofOfFix) ? proofOfFix : join19(cwd, proofOfFix);
-          if (existsSync14(resolvedPath)) {
-            reproductionTestPath = resolvedPath;
-          } else {
-            const safeName = packageName.replace(/^@/, "").replace(/\//g, "+");
-            reproductionTestPath = join19(patchesDirPath, `${safeName}+${vulnerableVersion}.test.cjs`);
-            await writeFile3(reproductionTestPath, proofOfFix, "utf8");
-          }
-        } else if (reproductionTest) {
-          const safeName = packageName.replace(/^@/, "").replace(/\//g, "+");
-          reproductionTestPath = join19(patchesDirPath, `${safeName}+${vulnerableVersion}.test.cjs`);
-          await writeFile3(reproductionTestPath, reproductionTest, "utf8");
-        }
-        const isProofOfFixActive = Boolean(proofOfFix || requireProofOfFix);
+        const preparedRepro = await prepareReproductionTestFile({
+          cwd,
+          packageName,
+          vulnerableVersion,
+          patchesDir: patchesDirPath,
+          proofOfFix,
+          reproductionTest
+        });
+        reproductionTestPath = preparedRepro.testFilePath;
+        const hasReproductionScript = Boolean(reproductionTestPath);
+        const isProofOfFixActive = Boolean(
+          hasReproductionScript || proofOfFix || requireProofOfFix
+        );
         if (isProofOfFixActive) {
           if (!reproductionTestPath) {
             if (requireProofOfFix) {
@@ -5806,6 +7104,7 @@ var applyPatchFileTool = defineTool({
                 vulnerableVersion,
                 applied: false,
                 dryRun: false,
+                unresolvedReason: "policy-blocked",
                 message: "Proof-of-fix verification required, but no reproduction test or script was supplied.",
                 patchFilePath,
                 manifestFilePath,
@@ -5833,7 +7132,7 @@ var applyPatchFileTool = defineTool({
               message: negativePhaseResult.passed ? "Reproduction test reproduced vulnerability on unpatched code." : void 0,
               error: negativePhaseResult.passed ? void 0 : negativePhaseResult.error
             });
-            if (!negativePhaseResult.passed && requireProofOfFix) {
+            if (!negativePhaseResult.passed) {
               await cleanupPatchArtifacts({
                 cwd,
                 patchFilePath,
@@ -5849,6 +7148,7 @@ var applyPatchFileTool = defineTool({
                 vulnerableVersion,
                 applied: false,
                 dryRun: false,
+                unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
                 message: `Proof-of-fix negative phase failed: ${negativePhaseResult.error}`,
                 patchFilePath,
                 manifestFilePath,
@@ -5913,7 +7213,7 @@ var applyPatchFileTool = defineTool({
         if (patchMode === "patch-package") {
           try {
             const [installCmd, ...installArgs] = installCommand;
-            await execa9(installCmd, installArgs, {
+            await execa8(installCmd, installArgs, {
               cwd,
               stdio: "pipe"
             });
@@ -6007,66 +7307,49 @@ var applyPatchFileTool = defineTool({
           });
         }
         let positivePhaseResult;
-        if (reproductionTestPath) {
-          if (isProofOfFixActive) {
-            positivePhaseResult = await runProofOfFixPhase({
-              stage: "positive",
-              testFilePath: reproductionTestPath,
-              cwd
-            });
-            validationPhases.push({
-              phase: "proof-of-fix-positive",
-              passed: positivePhaseResult.passed,
-              message: positivePhaseResult.passed ? "Reproduction test passed on patched code (vulnerability mitigated)." : void 0,
-              error: positivePhaseResult.passed ? void 0 : positivePhaseResult.error
+        if (reproductionTestPath && isProofOfFixActive) {
+          positivePhaseResult = await runProofOfFixPhase({
+            stage: "positive",
+            testFilePath: reproductionTestPath,
+            cwd
+          });
+          validationPhases.push({
+            phase: "proof-of-fix-positive",
+            passed: positivePhaseResult.passed,
+            message: positivePhaseResult.passed ? "Reproduction test passed on patched code (vulnerability mitigated)." : void 0,
+            error: positivePhaseResult.passed ? void 0 : positivePhaseResult.error
+          });
+          if (!positivePhaseResult.passed) {
+            await cleanupPatchArtifacts({
+              cwd,
+              patchFilePath,
+              manifestFilePath,
+              patchMode,
+              packageJsonSnapshot,
+              installCommand,
+              rerunInstall: patchMode === "patch-package"
             });
-            if (!positivePhaseResult.passed && (requireProofOfFix || validateWithTests)) {
-              await cleanupPatchArtifacts({
-                cwd,
-                patchFilePath,
-                manifestFilePath,
-                patchMode,
-                packageJsonSnapshot,
-                installCommand,
-                rerunInstall: patchMode === "patch-package"
-              });
-              return {
-                success: false,
-                packageName,
-                vulnerableVersion,
+            return {
+              success: false,
+              packageName,
+              vulnerableVersion,
+              applied: false,
+              dryRun: false,
+              unresolvedReason: requireProofOfFix ? "policy-blocked" : "proof-of-fix-failed",
+              message: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`,
+              patchFilePath,
+              manifestFilePath,
+              patchPath: patchFilePath,
+              patchMode,
+              postinstallConfigured: false,
+              patchArtifact: {
+                ...artifact,
                 applied: false,
-                dryRun: false,
-                message: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`,
-                patchFilePath,
-                manifestFilePath,
-                patchPath: patchFilePath,
-                patchMode,
-                postinstallConfigured: false,
-                patchArtifact: {
-                  ...artifact,
-                  applied: false,
-                  validationPhases
-                },
-                validationPhases,
-                error: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`
-              };
-            }
-          } else {
-            try {
-              const reproRun = await execa9("node", [reproductionTestPath], { cwd, stdio: "pipe" });
-              validationPhases.push({
-                phase: "reproduction-test",
-                passed: reproRun.exitCode === 0,
-                message: "Reproduction test verified fix successfully."
-              });
-            } catch (err) {
-              const reproErr = err instanceof Error ? err.message : String(err);
-              validationPhases.push({
-                phase: "reproduction-test",
-                passed: false,
-                error: `Reproduction test failed: ${reproErr}`
-              });
-            }
+                validationPhases
+              },
+              validationPhases,
+              error: `Proof-of-fix positive phase failed: ${positivePhaseResult.error}`
+            };
           }
         }
         let proofOfFixVerification;
@@ -6198,12 +7481,29 @@ function resolvePatchProvider(provider) {
 function shouldAttemptPatchFallback(result, preferVersionBump) {
   if (preferVersionBump) return false;
   if (result.applied || result.dryRun) return false;
-  return result.unresolvedReason === "no-safe-version" || result.unresolvedReason === "install-failed" || result.unresolvedReason === "override-apply-failed" || result.unresolvedReason === "validation-failed" || result.unresolvedReason === "major-bump-required" || result.unresolvedReason === "transitive-dependency";
+  return result.unresolvedReason === "no-safe-version" || result.unresolvedReason === "install-failed" || result.unresolvedReason === "override-apply-failed" || result.unresolvedReason === "validation-failed" || result.unresolvedReason === "major-bump-required" || result.unresolvedReason === "transitive-dependency" || result.unresolvedReason === "proof-of-fix-failed";
 }
 async function tryLocalPatchFallback(params) {
   const usage = [];
   let steps = 0;
   let consensusVerdict;
+  const loadedPolicy = loadPolicy(params.cwd, params.policy);
+  if (!isPackageAllowed(loadedPolicy, params.packageName)) {
+    return {
+      steps: 0,
+      usage,
+      result: {
+        packageName: params.packageName,
+        strategy: "none",
+        fromVersion: params.vulnerableVersion,
+        applied: false,
+        dryRun: params.dryRun,
+        dependencyScope: params.dependencyScope,
+        unresolvedReason: "policy-blocked",
+        message: `Policy denyPackages blocked patch fallback for package "${params.packageName}".`
+      }
+    };
+  }
   const sourceResult = await fetchPackageSourceTool.execute({
     packageName: params.packageName,
     version: params.vulnerableVersion
@@ -6382,7 +7682,7 @@ async function tryLocalPatchFallback(params) {
       riskLevel: patchResult.riskLevel,
       vulnerableRange: params.vulnerableRange,
       consensusVerdict,
-      unresolvedReason: !applyResult.applied && !applyResult.dryRun ? applyResult.validation?.passed === false ? "patch-validation-failed" : "patch-apply-failed" : void 0,
+      unresolvedReason: !applyResult.applied && !applyResult.dryRun ? applyResult.unresolvedReason ?? (applyResult.validation?.passed === false ? "patch-validation-failed" : "patch-apply-failed") : void 0,
       message: applyResult.message ?? applyResult.error ?? "Patch-file strategy finished.",
       validation: typeof applyResult.validation?.passed === "boolean" ? {
         passed: applyResult.validation.passed,
@@ -6448,7 +7748,7 @@ function resolveLocalRunOptions(options) {
 }
 
 // src/remediation/local/vulnerability-match.ts
-import semver5 from "semver";
+import semver6 from "semver";
 function findVulnerablePackages(cveDetails, installedPackages) {
   const vulnerablePackages = [];
   for (const affected of cveDetails.affectedPackages) {
@@ -6457,10 +7757,10 @@ function findVulnerablePackages(cveDetails, installedPackages) {
     if (affected.ecosystem !== "npm") continue;
     const matches = installedPackages.filter((pkg) => pkg.name === affected.name);
     for (const installed of matches) {
-      if (!semver5.valid(installed.version)) continue;
+      if (!semver6.valid(installed.version)) continue;
       let isVulnerable = false;
       try {
-        isVulnerable = semver5.satisfies(installed.version, affected.vulnerableRange, {
+        isVulnerable = semver6.satisfies(installed.version, affected.vulnerableRange, {
           includePrerelease: false
         });
       } catch {
@@ -6555,6 +7855,15 @@ function applyDispositionAndContainment(result, context) {
     dispositionReason: disposition.dispositionReason
   };
   if (context.containmentMode && withDisposition.disposition === "escalate" && withDisposition.applied) {
+    if (context.snapshot) {
+      restoreProjectSnapshotSync(context.snapshot);
+    }
+    if (context.onContainmentRollback) {
+      try {
+        context.onContainmentRollback();
+      } catch {
+      }
+    }
     return {
       ...withDisposition,
       applied: false,
@@ -6586,35 +7895,7 @@ function computeEscalationAction(reason, graph) {
 // src/remediation/local/run.ts
 async function runLocalRemediationPipeline(cveId, options = {}) {
   const resolved = resolveLocalRunOptions(options);
-  const {
-    cwd,
-    packageManager,
-    dryRun,
-    runTests,
-    policy,
-    patchesDir,
-    constraints,
-    llmProvider,
-    providerSafetyProfile,
-    requireConsensusForHighRisk,
-    consensusProvider,
-    consensusModel,
-    patchConfidenceThresholds,
-    dynamicModelRouting,
-    dynamicRoutingThresholdChars,
-    exploitSignalOverride,
-    suppressions,
-    suppressionsFile,
-    slaCheck,
-    slaPolicy,
-    skipUnreachable,
-    regressionCheck,
-    escalationGraph,
-    offlineIntelligence,
-    intelligenceSnapshotPath,
-    proofOfFix,
-    requireProofOfFix
-  } = resolved;
+  const { cwd, packageManager, dryRun, constraints } = resolved;
   const correlation = {
     requestId: options.requestId,
     sessionId: options.sessionId,
@@ -6628,10 +7909,10 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
   const normalizedId = cveId.toUpperCase();
   let osvDetails = null;
   let ghPackages = [];
-  if (offlineIntelligence) {
-    if (intelligenceSnapshotPath) {
+  if (resolved.offlineIntelligence) {
+    if (resolved.intelligenceSnapshotPath) {
       osvDetails = lookupSnapshotCve(
-        loadIntelligenceSnapshot(intelligenceSnapshotPath),
+        loadIntelligenceSnapshot(resolved.intelligenceSnapshotPath),
         normalizedId
       );
     }
@@ -6649,7 +7930,7 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
       vulnerablePackages,
       results: collectedResults,
       agentSteps,
-      summary: offlineIntelligence ? `Offline mode: ${normalizedId} not found in intelligence snapshot.` : `Local mode failed at lookup-cve: ${normalizedId} not found in OSV or GitHub advisory data.`,
+      summary: resolved.offlineIntelligence ? `Offline mode: ${normalizedId} not found in intelligence snapshot.` : `Local mode failed at lookup-cve: ${normalizedId} not found in OSV or GitHub advisory data.`,
       correlation
     };
   }
@@ -6663,16 +7944,10 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
   if (ghPackages.length > 0) {
     cveDetails = mergeGhDataIntoCveDetails(cveDetails, ghPackages);
   }
-  if (!offlineIntelligence) {
+  if (!resolved.offlineIntelligence) {
     cveDetails = await enrichWithNvd(cveDetails);
   }
-  const preflight = await runSecOpsPreflight(normalizedId, cveDetails, {
-    suppressions,
-    suppressionsFile,
-    exploitSignalOverride,
-    slaCheck,
-    slaPolicy
-  });
+  const preflight = await runSecOpsPreflight(normalizedId, cveDetails, resolved);
   if (preflight.suppressed) {
     return {
       cveId,
@@ -6721,35 +7996,57 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
   const installedPackages = inventory.packages ?? [];
   vulnerablePackages = findVulnerablePackages(cveDetails, installedPackages);
   agentSteps += 1;
-  const finalizePatchResult = (result) => {
-    const withDisposition = applyDispositionAndContainment(result, {
-      exploitSignalTriggered,
-      slaBreaches,
-      severity: cveDetails?.severity,
-      policy: options.dispositionPolicy,
-      containmentMode: options.containmentMode
-    });
-    if (withDisposition.unresolvedReason) {
-      withDisposition.escalationAction = computeEscalationAction(
-        withDisposition.unresolvedReason,
-        escalationGraph
-      );
-    }
-    return withDisposition;
-  };
+  const effectivePolicy = loadPolicy(cwd, options.policy);
+  const containmentMode = options.containmentMode ?? effectivePolicy.containmentMode ?? false;
+  const dispositionPolicy = options.dispositionPolicy ?? effectivePolicy.dispositionPolicy;
   for (const vulnerable of vulnerablePackages) {
-    if (skipUnreachable) {
-      const reach = assessPackageReachability(cwd, vulnerable.installed.name);
-      if (reach.status === "not-reachable") {
-        collectedResults.push({
+    const snapshot = await createProjectSnapshot(cwd);
+    const finalizePatchResult = (result) => {
+      const withDisposition = applyDispositionAndContainment(result, {
+        exploitSignalTriggered,
+        slaBreaches,
+        severity: cveDetails?.severity,
+        policy: dispositionPolicy,
+        containmentMode,
+        cwd,
+        snapshot
+      });
+      if (withDisposition.unresolvedReason) {
+        withDisposition.escalationAction = computeEscalationAction(
+          withDisposition.unresolvedReason,
+          resolved.escalationGraph
+        );
+      }
+      return withDisposition;
+    };
+    if (!isPackageAllowed(effectivePolicy, vulnerable.installed.name)) {
+      collectedResults.push(
+        finalizePatchResult({
           packageName: vulnerable.installed.name,
           fromVersion: vulnerable.installed.version,
           strategy: "none",
           applied: false,
           dryRun,
-          message: `Skipped: '${vulnerable.installed.name}' is not reachable from source code.`,
-          reachability: reach
-        });
+          unresolvedReason: "policy-blocked",
+          message: `Policy denyPackages blocked changes for package "${vulnerable.installed.name}".`
+        })
+      );
+      continue;
+    }
+    if (resolved.skipUnreachable) {
+      const reach = assessPackageReachability(cwd, vulnerable.installed.name);
+      if (reach.status === "not-reachable") {
+        collectedResults.push(
+          finalizePatchResult({
+            packageName: vulnerable.installed.name,
+            fromVersion: vulnerable.installed.version,
+            strategy: "none",
+            applied: false,
+            dryRun,
+            message: `Skipped: '${vulnerable.installed.name}' is not reachable from source code.`,
+            reachability: reach
+          })
+        );
         continue;
       }
     }
@@ -6758,9 +8055,13 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
       cwd,
       packageManager,
       dryRun,
-      policy,
-      runTests,
-      constraints
+      policy: resolved.policy,
+      runTests: resolved.runTests,
+      constraints,
+      proofOfFix: resolved.proofOfFix,
+      requireProofOfFix: resolved.requireProofOfFix,
+      reproductionTest: options.reproductionTest,
+      patchesDir: resolved.patchesDir
     });
     agentSteps += primary.steps;
     if (shouldAttemptPatchFallback(primary.result, constraints.preferVersionBump ?? false)) {
@@ -6773,26 +8074,26 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
         cveSummary: cveDetails?.summary ?? normalizedId,
         dependencyScope: vulnerable.installed.type === "direct" ? "direct" : "transitive",
         dryRun,
-        runTests,
-        patchesDir,
-        llmProvider,
+        runTests: resolved.runTests,
+        patchesDir: resolved.patchesDir,
+        llmProvider: resolved.llmProvider,
         model: options.model,
         policy: options.policy,
         modelPersonality: options.modelPersonality,
-        providerSafetyProfile,
-        requireConsensusForHighRisk,
-        consensusProvider,
-        consensusModel,
-        patchConfidenceThresholds,
-        dynamicModelRouting,
-        dynamicRoutingThresholdChars,
+        providerSafetyProfile: resolved.providerSafetyProfile,
+        requireConsensusForHighRisk: resolved.requireConsensusForHighRisk,
+        consensusProvider: resolved.consensusProvider,
+        consensusModel: resolved.consensusModel,
+        patchConfidenceThresholds: resolved.patchConfidenceThresholds,
+        dynamicModelRouting: resolved.dynamicModelRouting,
+        dynamicRoutingThresholdChars: resolved.dynamicRoutingThresholdChars,
         installMode: constraints.installMode,
         installPreferOffline: constraints.installPreferOffline,
         enforceFrozenLockfile: constraints.enforceFrozenLockfile,
         workspace: constraints.workspace,
         vulnerableRange: vulnerable.affected.vulnerableRange,
-        proofOfFix,
-        requireProofOfFix
+        proofOfFix: resolved.proofOfFix,
+        requireProofOfFix: resolved.requireProofOfFix
       });
       agentSteps += fallback.steps;
       collectedResults.push(finalizePatchResult(fallback.result));
@@ -6805,14 +8106,15 @@ async function runLocalRemediationPipeline(cveId, options = {}) {
       ...primary.result,
       dependencyScope: vulnerable.installed.type === "direct" ? "direct" : "transitive"
     };
-    if (regressionCheck && primaryResult.applied && !dryRun && primaryResult.toVersion) {
+    if (resolved.regressionCheck && primaryResult.applied && !dryRun && primaryResult.toVersion) {
       try {
-        if (semver6.satisfies(primaryResult.toVersion, vulnerable.affected.vulnerableRange, {
+        if (semver7.satisfies(primaryResult.toVersion, vulnerable.affected.vulnerableRange, {
           includePrerelease: false
         })) {
           primaryResult.regressionDetected = true;
         }
       } catch {
+        primaryResult.regressionDetected = false;
       }
     }
     collectedResults.push(finalizePatchResult(primaryResult));
@@ -6898,8 +8200,8 @@ function accumulateStepResults(params) {
 }
 
 // src/remediation/orchestration-prompt.ts
-import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
+import { join as join22 } from "path";
 function buildProviderAddendum(provider, personality = "balanced") {
   const personalityDirective = personality === "analytical" ? "Use concise, explicit rationale for tool decisions and unresolved outcomes." : personality === "pragmatic" ? "Prefer the smallest safe remediation path while preserving policy and validation gates." : "Balance concise execution with brief rationale for risky or unresolved outcomes.";
   const providerDirective = provider === "remote" ? "Use strict structured output and deterministic reporting fields." : "Use deterministic-first behavior and only rely on remote model fallback when required by patch generation.";
@@ -6910,13 +8212,13 @@ Provider profile:
 - ${personalityDirective}`;
 }
 function loadOrchestrationPrompt(ctx) {
-  const promptPath = join20(
+  const promptPath = join22(
     process.cwd(),
     ".github",
     "instructions",
     "orchestration.instructions.md"
   );
-  if (!existsSync15(promptPath)) {
+  if (!existsSync16(promptPath)) {
     return `You are autoremediator, an agentic security remediation system for Node.js package dependencies.
 Working directory: ${ctx.cwd}
   Package manager: ${ctx.packageManager}
@@ -6942,7 +8244,7 @@ Fallback sequence (when neither version bump nor override can be applied):
 
 Always respect dryRun and policy constraints.`;
   }
-  const template = readFileSync15(promptPath, "utf8");
+  const template = readFileSync17(promptPath, "utf8");
   return template.replaceAll("{{cveId}}", ctx.cveId).replaceAll("{{cwd}}", ctx.cwd).replaceAll("{{packageManager}}", ctx.packageManager).replaceAll("{{dryRun}}", String(ctx.dryRun)).replaceAll("{{runTests}}", String(ctx.runTests)).replaceAll("{{policy}}", ctx.policy || "undefined").replaceAll("{{patchesDir}}", ctx.patchesDir).replaceAll(
     "{{directDependenciesOnly}}",
     String(ctx.constraints.directDependenciesOnly ?? false)
@@ -6963,6 +8265,9 @@ function createProgressEmitter(options) {
   };
 }
 
+// src/remediation/pipeline-runtime/tool-wrappers.ts
+import { existsSync as existsSync17 } from "fs";
+
 // src/remediation/tools/lookup-cve.ts
 import { z as z9 } from "zod";
 
@@ -7249,7 +8554,7 @@ var lookupCveTool = defineTool({
 
 // src/remediation/tools/check-version-match.ts
 import { z as z10 } from "zod";
-import semver7 from "semver";
+import semver8 from "semver";
 var affectedPackageSchema = z10.object({
   name: z10.string(),
   ecosystem: z10.literal("npm"),
@@ -7278,10 +8583,10 @@ var checkVersionMatchTool = defineTool({
         (p) => p.name === affected.name
       );
       for (const installed of matches) {
-        if (!semver7.valid(installed.version)) continue;
+        if (!semver8.valid(installed.version)) continue;
         let isVulnerable = false;
         try {
-          isVulnerable = semver7.satisfies(installed.version, affected.vulnerableRange, {
+          isVulnerable = semver8.satisfies(installed.version, affected.vulnerableRange, {
             includePrerelease: false
           });
         } catch {
@@ -7301,6 +8606,7 @@ var checkVersionMatchTool = defineTool({
 
 // src/remediation/tools/find-fixed-version.ts
 import { z as z11 } from "zod";
+import semver9 from "semver";
 var findFixedVersionTool = defineTool({
   description: "Query the npm registry to find the safest published upgrade version for a package that is >= the first patched version. Prefer patch upgrades first, then minor, and only fall back to major when no same-major fix exists.",
   parameters: z11.object({
@@ -7332,9 +8638,11 @@ var findFixedVersionTool = defineTool({
         message: `No safe upgrade version found for "${packageName}". The patch-file path will be needed.`
       };
     }
-    const installedMajor = parseInt(installedVersion.split(".")[0] ?? "0", 10);
-    const safeMajor = parseInt(safeVersion.split(".")[0] ?? "0", 10);
-    const isMajorBump = safeMajor > installedMajor;
+    const parsedInstalled = semver9.parse(installedVersion) ?? semver9.coerce(installedVersion);
+    const parsedSafe = semver9.parse(safeVersion) ?? semver9.coerce(safeVersion);
+    const isMajorBump = Boolean(
+      parsedInstalled && parsedSafe && parsedSafe.major > parsedInstalled.major
+    );
     return {
       safeVersion,
       upgradeLevel,
@@ -7423,6 +8731,10 @@ function createRuntimeToolsForRun(options) {
       workspace: constraints.workspace,
       typecheck: input.typecheck ?? options.typecheck ?? constraints.typecheck,
       breakingChangeRefactor: input.breakingChangeRefactor ?? options.breakingChangeRefactor ?? constraints.enableBreakingChangeRefactor,
+      proofOfFix: input.proofOfFix ?? options.proofOfFix,
+      requireProofOfFix: input.requireProofOfFix ?? options.requireProofOfFix ?? constraints.requireProofOfFix,
+      reproductionTest: input.reproductionTest ?? options.reproductionTest,
+      patchesDir: input.patchesDir ?? options.patchesDir,
       dryRun: preview ? true : input.dryRun
     })
   };
@@ -7435,6 +8747,10 @@ function createRuntimeToolsForRun(options) {
       installPreferOffline: constraints.installPreferOffline,
       enforceFrozenLockfile: constraints.enforceFrozenLockfile,
       workspace: constraints.workspace,
+      proofOfFix: input.proofOfFix ?? options.proofOfFix,
+      requireProofOfFix: input.requireProofOfFix ?? options.requireProofOfFix ?? constraints.requireProofOfFix,
+      reproductionTest: input.reproductionTest ?? options.reproductionTest,
+      patchesDir: input.patchesDir ?? options.patchesDir,
       dryRun: preview ? true : input.dryRun
     })
   };
@@ -7449,6 +8765,8 @@ function createRuntimeToolsForRun(options) {
       workspace: constraints.workspace,
       proofOfFix: input.proofOfFix ?? options.proofOfFix,
       requireProofOfFix: input.requireProofOfFix ?? options.requireProofOfFix ?? constraints.requireProofOfFix,
+      reproductionTest: input.reproductionTest ?? options.reproductionTest,
+      patchesDir: input.patchesDir ?? options.patchesDir,
       dryRun: preview ? true : input.dryRun
     })
   };
@@ -7460,15 +8778,50 @@ function createRuntimeToolsForRun(options) {
     constraints
   });
   if (options.offlineIntelligence) {
-    const offlineMessage = options.intelligenceSnapshotPath ? `Offline mode: intelligence lookup via snapshot only. No live network calls.` : `Offline mode: intelligence lookup skipped (no snapshot provided).`;
+    let snapshot = null;
+    if (options.intelligenceSnapshotPath && existsSync17(options.intelligenceSnapshotPath)) {
+      try {
+        snapshot = loadIntelligenceSnapshot(options.intelligenceSnapshotPath);
+      } catch (err) {
+        const _ignored = err;
+        snapshot = null;
+      }
+    }
     tools["lookup-cve"] = {
       ...tools["lookup-cve"],
-      execute: async (_input) => ({
-        cveId: (_input.cveId ?? "unknown").toUpperCase(),
-        found: false,
-        offlineMode: true,
-        message: offlineMessage
-      })
+      execute: async (_input) => {
+        const cveId = (_input.cveId ?? "unknown").toUpperCase();
+        if (snapshot) {
+          const details = lookupSnapshotCve(snapshot, cveId);
+          if (details) {
+            return {
+              success: true,
+              found: true,
+              cveId,
+              offlineMode: true,
+              data: details,
+              message: `Offline mode: intelligence lookup resolved from snapshot for ${cveId}.`
+            };
+          }
+          return {
+            success: false,
+            found: false,
+            cveId,
+            offlineMode: true,
+            error: `Offline mode: ${cveId} not found in intelligence snapshot.`,
+            message: `Offline mode: ${cveId} not found in intelligence snapshot.`
+          };
+        }
+        const snapshotErrorMsg = options.intelligenceSnapshotPath ? `Offline mode: intelligence snapshot file not found or invalid at ${options.intelligenceSnapshotPath}.` : `Offline mode: intelligence lookup skipped (no snapshot provided).`;
+        return {
+          success: false,
+          found: false,
+          cveId,
+          offlineMode: true,
+          error: snapshotErrorMsg,
+          message: snapshotErrorMsg
+        };
+      }
     };
   }
   return tools;
@@ -7603,7 +8956,7 @@ async function runRemediationPipeline(cveId, options = {}) {
 }
 
 // src/api/change-request/index.ts
-import { execa as execa10 } from "execa";
+import { execa as execa9 } from "execa";
 import { randomBytes } from "crypto";
 function sanitizeBranchToken(value) {
   return value.toLowerCase().replace(/[^a-z0-9._/-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
@@ -7686,14 +9039,14 @@ function groupReports(reports, grouping) {
   return [reports];
 }
 async function detectCurrentBranch(cwd) {
-  const result = await execa10("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const result = await execa9("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd,
     stdio: "pipe"
   });
   return result.stdout.trim();
 }
 async function ensureRepoHasChanges(cwd) {
-  const diff = await execa10("git", ["status", "--porcelain"], {
+  const diff = await execa9("git", ["status", "--porcelain"], {
     cwd,
     stdio: "pipe"
   });
@@ -7703,7 +9056,59 @@ function toBranchName(prefix, cveIds) {
   const token = sanitizeBranchToken(cveIds.join("-") || "remediation");
   return `${sanitizeBranchToken(prefix)}/${token}-${randomBytes(6).toString("hex")}`;
 }
+async function detectRepoFromRemote(cwd) {
+  const result = await execa9("git", ["config", "--get", "remote.origin.url"], {
+    cwd,
+    stdio: "pipe"
+  }).catch(() => ({ stdout: "" }));
+  const url = result.stdout.trim();
+  const match = url.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (match) {
+    return `${match[1]}/${match[2]}`;
+  }
+  return void 0;
+}
+async function ensureRepoHasStagedChanges(cwd) {
+  const result = await execa9("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    stdio: "pipe"
+  }).catch(() => ({ stdout: "" }));
+  return result.stdout.trim().length > 0;
+}
 async function createGitHubRequest(params) {
+  const token = params.token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+  let repository = params.repository;
+  if (!repository) {
+    repository = await detectRepoFromRemote(params.cwd);
+  }
+  if (token && repository) {
+    const [owner, repo] = repository.split("/");
+    const baseUrl = params.githubApiUrl?.replace(/\/+$/, "") || "https://api.github.com";
+    const endpoint = `${baseUrl}/repos/${owner}/${repo}/pulls`;
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        accept: "application/vnd.github+json",
+        "content-type": "application/json",
+        "user-agent": "autoremediator",
+        "x-github-api-version": "2022-11-28"
+      },
+      body: JSON.stringify({
+        title: params.title,
+        head: params.head,
+        base: params.base,
+        body: params.body,
+        draft: Boolean(params.draft)
+      })
+    });
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      throw new Error(`GitHub API create pull request failed (${response.status}): ${errText}`);
+    }
+    const data = await response.json();
+    return data.html_url || void 0;
+  }
   const args = [
     "pr",
     "create",
@@ -7722,7 +9127,7 @@ async function createGitHubRequest(params) {
   if (params.draft) {
     args.push("--draft");
   }
-  const result = await execa10("gh", args, {
+  const result = await execa9("gh", args, {
     cwd: params.cwd,
     stdio: "pipe"
   });
@@ -7747,7 +9152,7 @@ async function createGitLabRequest(params) {
   if (params.draft) {
     args.push("--draft");
   }
-  const result = await execa10("glab", args, {
+  const result = await execa9("glab", args, {
     cwd: params.cwd,
     stdio: "pipe"
   });
@@ -7762,7 +9167,7 @@ async function createChangeRequestsForReports(params) {
     return [];
   }
   const results = [];
-  const hasChanges = await ensureRepoHasChanges(cwd).catch(() => false);
+  const token = options.token ?? (options.tokenEnvVar ? process.env[options.tokenEnvVar] : void 0) ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
   const baseBranch = options.baseBranch ?? await detectCurrentBranch(cwd).catch(() => "main");
   const branchPrefix = options.branchPrefix ?? "autoremediator";
   const pushRemote = options.pushRemote ?? "origin";
@@ -7780,6 +9185,7 @@ async function createChangeRequestsForReports(params) {
     const body = bodyFooter ? `${plan.body}
 
 ${bodyFooter}` : plan.body;
+    const hasChanges = await ensureRepoHasChanges(cwd).catch(() => false);
     if (!hasChanges) {
       results.push({
         provider,
@@ -7796,11 +9202,49 @@ ${bodyFooter}` : plan.body;
       continue;
     }
     const branchName = toBranchName(branchPrefix, plan.cveIds);
+    let branchCreated = false;
     try {
-      await execa10("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
-      await execa10("git", ["add", "-A"], { cwd, stdio: "pipe" });
-      await execa10("git", ["commit", "-m", title], { cwd, stdio: "pipe" });
-      await execa10("git", ["push", "-u", pushRemote, branchName], { cwd, stdio: "pipe" });
+      await execa9("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
+      branchCreated = true;
+      await execa9("git", ["add", "-A"], { cwd, stdio: "pipe" });
+      const hasStaged = await ensureRepoHasStagedChanges(cwd);
+      if (!hasStaged) {
+        results.push({
+          provider,
+          grouping,
+          repository: options.repository,
+          branchName: "",
+          title,
+          body,
+          created: false,
+          cveIds: plan.cveIds,
+          packageNames: plan.packageNames,
+          error: "No repository changes to include in change request."
+        });
+        continue;
+      }
+      await execa9(
+        "git",
+        [
+          "-c",
+          "user.name=autoremediator[bot]",
+          "-c",
+          "user.email=41898282+github-actions[bot]@users.noreply.github.com",
+          "commit",
+          "-m",
+          title
+        ],
+        { cwd, stdio: "pipe" }
+      );
+      const pushArgs = token ? [
+        "-c",
+        `http.extraheader=AUTHORIZATION: basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`,
+        "push",
+        "-u",
+        pushRemote,
+        branchName
+      ] : ["push", "-u", pushRemote, branchName];
+      await execa9("git", pushArgs, { cwd, stdio: "pipe" });
       const url = provider === "github" ? await createGitHubRequest({
         cwd,
         repository: options.repository,
@@ -7808,7 +9252,9 @@ ${bodyFooter}` : plan.body;
         base: baseBranch,
         title,
         body,
-        draft: options.draft
+        draft: options.draft,
+        token,
+        githubApiUrl: options.githubApiUrl
       }) : await createGitLabRequest({
         cwd,
         repository: options.repository,
@@ -7831,10 +9277,6 @@ ${bodyFooter}` : plan.body;
         cveIds: plan.cveIds,
         packageNames: plan.packageNames
       });
-      if (groups.length > 1) {
-        await execa10("git", ["checkout", baseBranch], { cwd, stdio: "pipe" }).catch(() => {
-        });
-      }
     } catch (error) {
       results.push({
         provider,
@@ -7849,6 +9291,11 @@ ${bodyFooter}` : plan.body;
         packageNames: plan.packageNames,
         error: error instanceof Error ? error.message : String(error)
       });
+    } finally {
+      if (branchCreated) {
+        await execa9("git", ["checkout", baseBranch], { cwd, stdio: "pipe" }).catch(() => {
+        });
+      }
     }
   }
   return results;
@@ -7888,8 +9335,8 @@ function resolveConstraints(options, cwd) {
 }
 
 // src/platform/evidence.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync6 } from "fs";
-import { join as join21 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync9 } from "fs";
+import { join as join23 } from "path";
 function createEvidenceLog(cwd, cveIds, context = {}) {
   return {
     runId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
@@ -7921,10 +9368,10 @@ function finalizeEvidence(log) {
   return log;
 }
 function writeEvidenceLog(cwd, log) {
-  const dir = join21(cwd, ".autoremediator", "evidence");
-  mkdirSync3(dir, { recursive: true });
-  const filePath = join21(dir, `${log.runId}.json`);
-  writeFileSync6(filePath, JSON.stringify(log, null, 2) + "\n", "utf8");
+  const dir = join23(cwd, ".autoremediator", "evidence");
+  mkdirSync5(dir, { recursive: true });
+  const filePath = join23(dir, `${log.runId}.json`);
+  writeFileSync9(filePath, JSON.stringify(log, null, 2) + "\n", "utf8");
   return filePath;
 }
 
@@ -8166,12 +9613,12 @@ async function planRemediation(cveId, options = {}) {
 }
 
 // src/scanner/parse-input.ts
-import { extname, resolve as resolve5 } from "path";
-import { readFileSync as readFileSync19 } from "fs";
-import { execa as execa11 } from "execa";
+import { extname, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync21 } from "fs";
+import { execa as execa10 } from "execa";
 
 // src/scanner/adapters/npm-audit.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 var CVE_REGEX = /CVE-\d{4}-\d{1,7}/gi;
 var GHSA_REGEX = /GHSA-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}/gi;
 function normalizeSeverity(raw) {
@@ -8207,12 +9654,12 @@ function parseNpmAuditJsonFromString(content) {
   return findings;
 }
 function parseNpmAuditJsonFile(filePath) {
-  const content = readFileSync16(filePath, "utf8");
+  const content = readFileSync18(filePath, "utf8");
   return parseNpmAuditJsonFromString(content);
 }
 
 // src/scanner/adapters/yarn-audit.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 var CVE_REGEX2 = /CVE-\d{4}-\d{1,7}/gi;
 var GHSA_REGEX2 = /GHSA-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}/gi;
 function normalizeSeverity2(raw) {
@@ -8257,12 +9704,12 @@ function parseYarnAuditJsonFromString(content) {
   return findings;
 }
 function parseYarnAuditJsonFile(filePath) {
-  const content = readFileSync17(filePath, "utf8");
+  const content = readFileSync19(filePath, "utf8");
   return parseYarnAuditJsonFromString(content);
 }
 
 // src/scanner/adapters/sarif.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 var CVE_REGEX3 = /CVE-\d{4}-\d{1,7}/gi;
 function extractPackageName(result) {
   const pkg = result.properties?.["packageName"];
@@ -8300,7 +9747,7 @@ function parseSarifFromString(content) {
   return findings;
 }
 function parseSarifFile(filePath) {
-  const content = readFileSync18(filePath, "utf8");
+  const content = readFileSync20(filePath, "utf8");
   return parseSarifFromString(content);
 }
 
@@ -8309,7 +9756,7 @@ function parseScanInput(filePath, format) {
   if (filePath.includes("\0")) {
     throw new Error("Invalid scan input path: path contains null bytes");
   }
-  const resolvedPath = resolve5(filePath);
+  const resolvedPath = resolve4(filePath);
   const resolved = format === "auto" ? inferFormat(resolvedPath) : format;
   if (resolved === "npm-audit") {
     return parseNpmAuditJsonFile(resolvedPath);
@@ -8331,7 +9778,7 @@ async function parseScanInputFromAudit(params) {
   }
   const command = resolveAuditCommand(pm, { workspace: params.workspace });
   const [cmd, ...args] = command;
-  const result = await execa11(cmd, args, {
+  const result = await execa10(cmd, args, {
     cwd: params.cwd,
     stdio: "pipe",
     reject: false
@@ -8385,7 +9832,7 @@ function inferFormat(filePath) {
   const ext = extname(filePath).toLowerCase();
   if (ext === ".sarif") return "sarif";
   try {
-    const content = readFileSync19(filePath, "utf8");
+    const content = readFileSync21(filePath, "utf8");
     const firstLine = content.split("\n").find((line) => line.trim().startsWith("{"));
     if (firstLine) {
       const parsed = JSON.parse(firstLine);
@@ -8421,9 +9868,6 @@ async function executeScanRemediations(params) {
         source: params.provenance.source,
         constraints: params.constraints
       });
-      report.results = report.results.filter(
-        (result) => isPackageAllowed(params.policy, result.packageName)
-      );
       for (const result of report.results) {
         if (result.strategy === "patch-file") {
           patchCount += 1;
@@ -8796,14 +10240,14 @@ async function remediatePortfolio(targets, options = {}) {
 }
 
 // src/api/update-outdated/index.ts
-import { join as join22 } from "path";
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync7 } from "fs";
-import { execa as execa12 } from "execa";
+import { join as join24 } from "path";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync10 } from "fs";
+import { execa as execa11 } from "execa";
 async function applyBump(params) {
-  const pkgPath = join22(params.cwd, "package.json");
+  const pkgPath = join24(params.cwd, "package.json");
   let pkgJson;
   try {
-    pkgJson = JSON.parse(readFileSync20(pkgPath, "utf8"));
+    pkgJson = JSON.parse(readFileSync22(pkgPath, "utf8"));
   } catch {
     return {
       applied: false,
@@ -8825,13 +10269,13 @@ async function applyBump(params) {
   const newRange = `${prefix}${params.toVersion}`;
   return withRepoLock(params.cwd, async () => {
     pkgJson[depField][params.packageName] = newRange;
-    writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+    writeFileSync10(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
     try {
       const [installCmd, ...installArgs] = params.installCommand;
-      await execa12(installCmd, installArgs, { cwd: params.cwd, stdio: "pipe" });
+      await execa11(installCmd, installArgs, { cwd: params.cwd, stdio: "pipe" });
     } catch (err) {
       pkgJson[depField][params.packageName] = currentRange;
-      writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+      writeFileSync10(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
       const message = err instanceof Error ? err.message : String(err);
       return {
         applied: false,
@@ -8841,13 +10285,13 @@ async function applyBump(params) {
     if (params.runTests) {
       try {
         const [testCmd, ...testArgs] = params.testCommand;
-        await execa12(testCmd, testArgs, { cwd: params.cwd, stdio: "pipe" });
+        await execa11(testCmd, testArgs, { cwd: params.cwd, stdio: "pipe" });
       } catch (err) {
         pkgJson[depField][params.packageName] = currentRange;
-        writeFileSync7(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+        writeFileSync10(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
         try {
           const [rollbackCmd, ...rollbackArgs] = params.installCommand;
-          await execa12(rollbackCmd, rollbackArgs, { cwd: params.cwd, stdio: "pipe" });
+          await execa11(rollbackCmd, rollbackArgs, { cwd: params.cwd, stdio: "pipe" });
         } catch {
         }
         const message = err instanceof Error ? err.message : String(err);
@@ -9049,19 +10493,19 @@ async function checkReachability(options) {
 }
 
 // src/scanner/delta-scan.ts
-import { existsSync as existsSync16, readFileSync as readFileSync21 } from "fs";
-import { join as join23 } from "path";
-import { execa as execa13 } from "execa";
-import semver9 from "semver";
+import { existsSync as existsSync18, readFileSync as readFileSync23 } from "fs";
+import { join as join25 } from "path";
+import { execa as execa12 } from "execa";
+import semver11 from "semver";
 
 // src/scanner/lockfile-diff.ts
 import YAML2 from "yaml";
-import semver8 from "semver";
+import semver10 from "semver";
 function parseLockfileDependencies(filename, content) {
   const result = /* @__PURE__ */ new Map();
   const add = (name, ver) => {
     if (!name || !ver) return;
-    const cleanVer = semver8.clean(ver) || semver8.coerce(ver)?.version || ver;
+    const cleanVer = semver10.clean(ver) || semver10.coerce(ver)?.version || ver;
     let set = result.get(name);
     if (!set) {
       set = /* @__PURE__ */ new Set();
@@ -9181,9 +10625,9 @@ function computeLockfileDiff(filename, oldContent, newContent) {
           });
         } else {
           const [firstOld] = oldVers;
-          const cleanOld = semver8.clean(firstOld) || semver8.coerce(firstOld)?.version;
-          const cleanNew = semver8.clean(nVer) || semver8.coerce(nVer)?.version;
-          const isUpgrade = cleanOld && cleanNew && semver8.valid(cleanOld) && semver8.valid(cleanNew) ? semver8.gt(cleanNew, cleanOld) : true;
+          const cleanOld = semver10.clean(firstOld) || semver10.coerce(firstOld)?.version;
+          const cleanNew = semver10.clean(nVer) || semver10.coerce(nVer)?.version;
+          const isUpgrade = cleanOld && cleanNew && semver10.valid(cleanOld) && semver10.valid(cleanNew) ? semver10.gt(cleanNew, cleanOld) : true;
           changes.push({
             packageName: pkg,
             changeType: isUpgrade ? "upgraded" : "downgraded",
@@ -9220,7 +10664,7 @@ var DEP_SECTIONS = [
 async function getChangedManifestPaths(cwd, baseRef) {
   const manifests = /* @__PURE__ */ new Set();
   try {
-    const { stdout: diffFiles } = await execa13(
+    const { stdout: diffFiles } = await execa12(
       "git",
       ["diff", "--name-only", baseRef, "--", "package.json", "**/package.json"],
       { cwd, reject: false }
@@ -9231,7 +10675,7 @@ async function getChangedManifestPaths(cwd, baseRef) {
         manifests.add(trimmed);
       }
     }
-    const { stdout: untrackedFiles } = await execa13(
+    const { stdout: untrackedFiles } = await execa12(
       "git",
       ["ls-files", "--others", "--exclude-standard", "--", "package.json", "**/package.json"],
       { cwd, reject: false }
@@ -9243,7 +10687,7 @@ async function getChangedManifestPaths(cwd, baseRef) {
       }
     }
   } catch {
-    if (existsSync16(join23(cwd, "package.json"))) {
+    if (existsSync18(join25(cwd, "package.json"))) {
       manifests.add("package.json");
     }
   }
@@ -9251,7 +10695,7 @@ async function getChangedManifestPaths(cwd, baseRef) {
 }
 async function getOldManifestContent(cwd, baseRef, relPath) {
   try {
-    const { stdout } = await execa13("git", ["show", `${baseRef}:${relPath}`], {
+    const { stdout } = await execa12("git", ["show", `${baseRef}:${relPath}`], {
       cwd,
       reject: false
     });
@@ -9262,10 +10706,10 @@ async function getOldManifestContent(cwd, baseRef, relPath) {
   }
 }
 function getNewManifestContent(cwd, relPath) {
-  const fullPath = join23(cwd, relPath);
-  if (!existsSync16(fullPath)) return null;
+  const fullPath = join25(cwd, relPath);
+  if (!existsSync18(fullPath)) return null;
   try {
-    return JSON.parse(readFileSync21(fullPath, "utf8"));
+    return JSON.parse(readFileSync23(fullPath, "utf8"));
   } catch {
     return null;
   }
@@ -9286,9 +10730,9 @@ function computeDependencyDiff(relPath, oldPkg, newPkg) {
           manifestPath: relPath
         });
       } else if (oldVer !== newVer) {
-        const cleanOld = semver9.clean(oldVer) || semver9.coerce(oldVer)?.version;
-        const cleanNew = semver9.clean(newVer) || semver9.coerce(newVer)?.version;
-        const isUpgrade = cleanOld && cleanNew && semver9.valid(cleanOld) && semver9.valid(cleanNew) ? semver9.gt(cleanNew, cleanOld) : true;
+        const cleanOld = semver11.clean(oldVer) || semver11.coerce(oldVer)?.version;
+        const cleanNew = semver11.clean(newVer) || semver11.coerce(newVer)?.version;
+        const isUpgrade = cleanOld && cleanNew && semver11.valid(cleanOld) && semver11.valid(cleanNew) ? semver11.gt(cleanNew, cleanOld) : true;
         changes.push({
           packageName: pkgName,
           changeType: isUpgrade ? "upgraded" : "downgraded",
@@ -9324,7 +10768,7 @@ var LOCKFILE_PATTERNS = [
 async function getChangedLockfilePaths(cwd, baseRef) {
   const lockfiles = /* @__PURE__ */ new Set();
   try {
-    const { stdout: diffFiles } = await execa13(
+    const { stdout: diffFiles } = await execa12(
       "git",
       ["diff", "--name-only", baseRef, "--", ...LOCKFILE_PATTERNS],
       { cwd, reject: false }
@@ -9335,7 +10779,7 @@ async function getChangedLockfilePaths(cwd, baseRef) {
         lockfiles.add(trimmed);
       }
     }
-    const { stdout: untrackedFiles } = await execa13(
+    const { stdout: untrackedFiles } = await execa12(
       "git",
       ["ls-files", "--others", "--exclude-standard", "--", ...LOCKFILE_PATTERNS],
       { cwd, reject: false }
@@ -9352,7 +10796,7 @@ async function getChangedLockfilePaths(cwd, baseRef) {
 }
 async function getFileContentAtRef(cwd, baseRef, relPath) {
   try {
-    const { stdout } = await execa13("git", ["show", `${baseRef}:${relPath}`], {
+    const { stdout } = await execa12("git", ["show", `${baseRef}:${relPath}`], {
       cwd,
       reject: false
     });
@@ -9379,8 +10823,8 @@ async function scanDelta(options = {}) {
   }
   for (const lockfileRel of changedLockfiles) {
     const oldContent = await getFileContentAtRef(cwd, baseRef, lockfileRel);
-    const fullPath = join23(cwd, lockfileRel);
-    const newContent = existsSync16(fullPath) ? readFileSync21(fullPath, "utf8") : null;
+    const fullPath = join25(cwd, lockfileRel);
+    const newContent = existsSync18(fullPath) ? readFileSync23(fullPath, "utf8") : null;
     const lockDiffs = computeLockfileDiff(lockfileRel, oldContent, newContent);
     for (const change of lockDiffs) {
       if (!directPkgs.has(change.packageName)) {
@@ -9395,7 +10839,7 @@ async function scanDelta(options = {}) {
   const resolvedFindings = [];
   for (const change of dependencyChanges) {
     if (change.changeType === "added" || change.changeType === "upgraded" || change.changeType === "downgraded") {
-      const cleanVer = semver9.coerce(change.newVersion)?.version ?? change.newVersion;
+      const cleanVer = semver11.coerce(change.newVersion)?.version ?? change.newVersion;
       const evaluation = await evaluatePackage(change.packageName, {
         version: cleanVer,
         enrichIntelligence: true
@@ -9415,12 +10859,12 @@ async function scanDelta(options = {}) {
       }
     }
     if (change.oldVersion && (change.changeType === "upgraded" || change.changeType === "removed")) {
-      const cleanOldVer = semver9.coerce(change.oldVersion)?.version ?? change.oldVersion;
+      const cleanOldVer = semver11.coerce(change.oldVersion)?.version ?? change.oldVersion;
       const oldEval = await evaluatePackage(change.packageName, {
         version: cleanOldVer,
         enrichIntelligence: true
       });
-      const cleanNewVer = change.newVersion ? semver9.coerce(change.newVersion)?.version ?? change.newVersion : void 0;
+      const cleanNewVer = change.newVersion ? semver11.coerce(change.newVersion)?.version ?? change.newVersion : void 0;
       const newEval = cleanNewVer ? await evaluatePackage(change.packageName, {
         version: cleanNewVer,
         enrichIntelligence: false
@@ -9472,7 +10916,145 @@ async function scanDelta(options = {}) {
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/platform/jobs.ts
-var jobRegistry = /* @__PURE__ */ new Map();
+var BoundedJobRegistry = class extends Map {
+  maxCapacity;
+  ttlMs;
+  constructor(options = {}) {
+    super();
+    this.maxCapacity = options.maxCapacity ?? 1e3;
+    this.ttlMs = options.ttlMs ?? 24 * 60 * 60 * 1e3;
+  }
+  getMaxCapacity() {
+    return this.maxCapacity;
+  }
+  setMaxCapacity(capacity) {
+    if (capacity <= 0) {
+      throw new Error(`maxCapacity must be greater than 0, received ${capacity}`);
+    }
+    this.maxCapacity = capacity;
+    this.enforceCapacity();
+  }
+  getTtl() {
+    return this.ttlMs;
+  }
+  setTtl(ttlMs) {
+    if (ttlMs <= 0) {
+      throw new Error(`ttlMs must be greater than 0, received ${ttlMs}`);
+    }
+    this.ttlMs = ttlMs;
+  }
+  isExpired(job, now = Date.now()) {
+    const timestampStr = job.completedAt ?? job.submittedAt;
+    const timeMs = new Date(timestampStr).getTime();
+    if (isNaN(timeMs)) return false;
+    return now - timeMs > this.ttlMs;
+  }
+  evictExpired(now = Date.now()) {
+    let count = 0;
+    for (const [id, job] of super.entries()) {
+      if (this.isExpired(job, now)) {
+        super.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+  prune(now = Date.now()) {
+    return this.evictExpired(now);
+  }
+  get(jobId) {
+    const job = super.get(jobId);
+    if (!job) return void 0;
+    if (this.isExpired(job)) {
+      super.delete(jobId);
+      return void 0;
+    }
+    return job;
+  }
+  has(jobId) {
+    const job = super.get(jobId);
+    if (!job) return false;
+    if (this.isExpired(job)) {
+      super.delete(jobId);
+      return false;
+    }
+    return true;
+  }
+  set(jobId, job) {
+    if (super.has(jobId)) {
+      super.set(jobId, job);
+      return this;
+    }
+    this.evictExpired();
+    if (this.size >= this.maxCapacity) {
+      this.evictOneCandidate();
+    }
+    super.set(jobId, job);
+    return this;
+  }
+  evictOneCandidate() {
+    let oldestTerminalId;
+    let oldestTerminalTime = Infinity;
+    let oldestOverallId;
+    let oldestOverallTime = Infinity;
+    for (const [id, job] of super.entries()) {
+      const submittedMs = new Date(job.submittedAt).getTime() || 0;
+      if (submittedMs < oldestOverallTime) {
+        oldestOverallTime = submittedMs;
+        oldestOverallId = id;
+      }
+      if (job.status === "done" || job.status === "failed") {
+        const terminalMs = new Date(job.completedAt ?? job.submittedAt).getTime() || 0;
+        if (terminalMs < oldestTerminalTime) {
+          oldestTerminalTime = terminalMs;
+          oldestTerminalId = id;
+        }
+      }
+    }
+    const targetId = oldestTerminalId ?? oldestOverallId;
+    if (targetId) {
+      super.delete(targetId);
+    }
+  }
+  enforceCapacity() {
+    this.evictExpired();
+    while (this.size > this.maxCapacity) {
+      this.evictOneCandidate();
+    }
+  }
+  stats() {
+    let pending = 0;
+    let running = 0;
+    let done = 0;
+    let failed = 0;
+    for (const job of super.values()) {
+      switch (job.status) {
+        case "pending":
+          pending++;
+          break;
+        case "running":
+          running++;
+          break;
+        case "done":
+          done++;
+          break;
+        case "failed":
+          failed++;
+          break;
+      }
+    }
+    return {
+      size: this.size,
+      maxCapacity: this.maxCapacity,
+      ttlMs: this.ttlMs,
+      pending,
+      running,
+      done,
+      failed
+    };
+  }
+};
+var jobRegistry = new BoundedJobRegistry();
 
 // src/api/jobs/index.ts
 function createJob() {