@dev-tren/mapd 0.21.0

package/src/core/fixApply.js

@@ -0,0 +1,172 @@
+/**
+ * fixApply.js — shared selection and post-apply safety for verified fix
+ * proposals. `review.transition` still performs the actual approved write;
+ * this layer adds the "prove the real tree stayed healthy, otherwise roll
+ * back the recorded backup" behavior used by CLI/chat/MCP.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { buildScoredGraph } from "./intelligence.js";
+import { loadPkg } from "./graph.js";
+import { runProjectCorrectnessGate } from "./gates.js";
+import { transition } from "./review.js";
+import { rollbackChange } from "./changes.js";
+
+const SEVERITY_RANK = { critical: 4, high: 3, medium: 2, low: 1 };
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function isFixableFinding(item) {
+  return item?.status === "awaiting-approval" &&
+    (item.source === "check" || item.source?.startsWith("modernize-"));
+}
+
+function itemPriority(item) {
+  const severity = SEVERITY_RANK[item.severity] ?? 0;
+  const priority = Number(item.priority);
+  return severity * 1000 + (Number.isFinite(priority) ? priority : 0);
+}
+
+/** Pick the strongest open finding when the user intentionally omits an ID. */
+export function chooseFixTarget(items = []) {
+  return items
+    .filter(isFixableFinding)
+    .slice()
+    .sort((a, b) =>
+      itemPriority(b) - itemPriority(a) ||
+      (a.source ?? "").localeCompare(b.source ?? "") ||
+      (a.id ?? "").localeCompare(b.id ?? ""),
+    )[0] ?? null;
+}
+
+export function comparePostApplyHealth(preGraph, postGraph) {
+  const preConfidence = Number(preGraph?.repoConfidence ?? 0);
+  const postConfidence = Number(postGraph?.repoConfidence ?? 0);
+  const preWorkflows = preGraph?.workflows ?? [];
+  const postWorkflows = postGraph?.workflows ?? [];
+  const postIds = new Set(postWorkflows.map((w) => w.id));
+  const missingWorkflowIds = preWorkflows.map((w) => w.id).filter((id) => !postIds.has(id));
+  const issues = [];
+
+  if (postConfidence < preConfidence) {
+    issues.push(`repo confidence dropped from ${preConfidence} to ${postConfidence}`);
+  }
+  if (postWorkflows.length < preWorkflows.length) {
+    issues.push(`workflow count dropped from ${preWorkflows.length} to ${postWorkflows.length}`);
+  }
+  if (missingWorkflowIds.length) {
+    issues.push(`workflow(s) disappeared after apply: ${missingWorkflowIds.join(", ")}`);
+  }
+
+  return {
+    ok: issues.length === 0,
+    issues,
+    preConfidence,
+    postConfidence,
+    preWorkflowCount: preWorkflows.length,
+    postWorkflowCount: postWorkflows.length,
+    missingWorkflowIds,
+  };
+}
+
+function firstUsefulLine(...texts) {
+  for (const text of texts) {
+    const line = String(text ?? "").split(/\r?\n/).find((l) => l.trim());
+    if (line) return line.trim();
+  }
+  return "";
+}
+
+function correctnessIssues(gate) {
+  if (gate.passed) return [];
+  return (gate.checks ?? [])
+    .filter((c) => !c.passed)
+    .map((c) => {
+      const detail = firstUsefulLine(c.stderr, c.stdout);
+      return `${c.script} failed${c.exitCode != null ? ` (exit ${c.exitCode})` : ""}${detail ? `: ${detail}` : ""}`;
+    });
+}
+
+export function runPostApplyVerification(rootDir, preGraph, config = {}) {
+  const abs = path.resolve(rootDir);
+  const postGraph = buildScoredGraph(abs);
+  const health = comparePostApplyHealth(preGraph, postGraph);
+  const correctness = runProjectCorrectnessGate({
+    cwd: abs,
+    pkg: loadPkg(abs),
+    runTests: config.fix?.runTests,
+    runLint: config.fix?.runLint,
+    runTypecheck: config.fix?.runTypecheck,
+  });
+  const issues = [...health.issues, ...correctnessIssues(correctness)];
+  return { ok: issues.length === 0, issues, health, correctness };
+}
+
+function recordProposalPostApply(item, status, postApplyVerification, rollbackResults = []) {
+  if (!item?.file) return;
+  const prop = readJson(item.file);
+  if (!prop) return;
+  if (status) prop.status = status;
+  prop.postApplyVerification = {
+    ok: postApplyVerification.ok,
+    at: new Date().toISOString(),
+    issues: postApplyVerification.issues,
+    health: postApplyVerification.health,
+    correctness: postApplyVerification.correctness,
+    rollbackResults,
+  };
+  fs.writeFileSync(item.file, JSON.stringify(prop, null, 2));
+}
+
+/**
+ * Approve a saved fix proposal, then verify the real tree. If tests/lint/
+ * typecheck fail, repo confidence drops, or workflows disappear, immediately
+ * roll back the recorded change IDs from changes.js.
+ */
+export function approveFixWithPostApplyVerification(rootDir, item, config = {}) {
+  const abs = path.resolve(rootDir);
+  if (item?.source !== "fix") {
+    return { ok: false, action: "approve", detail: "post-apply verification only applies to fix proposals" };
+  }
+
+  const preGraph = buildScoredGraph(abs);
+  let applied;
+  try {
+    applied = transition(abs, item, "approve");
+  } catch (e) {
+    return { ok: false, action: "approve", detail: e.message };
+  }
+  if (!applied.ok) return applied;
+
+  const changeIds = applied.changeIds ?? [];
+  const postApplyVerification = runPostApplyVerification(abs, preGraph, config);
+  if (postApplyVerification.ok) {
+    recordProposalPostApply(item, null, postApplyVerification);
+    return { ...applied, changeIds, postApplyVerification };
+  }
+
+  const rollbackResults = [];
+  for (const changeId of changeIds.slice().reverse()) {
+    try {
+      rollbackResults.push({ changeId, ...rollbackChange(abs, changeId) });
+    } catch (e) {
+      rollbackResults.push({ changeId, ok: false, detail: e.message });
+    }
+  }
+  const rolledBack = rollbackResults.every((r) => r.ok);
+  const status = rolledBack ? "rolled-back-after-apply" : "post-apply-failed-rollback-incomplete";
+  recordProposalPostApply(item, status, postApplyVerification, rollbackResults);
+
+  return {
+    ok: false,
+    action: "approve",
+    detail: `post-apply verification failed; ${rolledBack ? "rolled back" : "rollback incomplete"} (${postApplyVerification.issues.join("; ")})`,
+    originalDetail: applied.detail,
+    changeIds,
+    rollbackResults,
+    postApplyVerification,
+  };
+}

package/src/core/frameworkEntries.js

@@ -0,0 +1,247 @@
+/**
+ * frameworkEntries.js — framework-specific entry-point detection beyond the
+ * generic bin/main/npm-script/route-call-site heuristics in graph.js.
+ *
+ * DESIGN RULE (same as parser.js): every detector here either verifies its
+ * finding against real AST structure and confirms the resolved file actually
+ * exists in the project, or it detects nothing. No pattern here guesses at a
+ * file that might exist — a miss is acceptable, a fabricated entry is not.
+ */
+
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import fs from "node:fs";
+import path from "node:path";
+
+const traverse = _traverse.default ?? _traverse;
+
+const BABEL_OPTS = { sourceType: "unambiguous", errorRecovery: true, plugins: ["typescript", "jsx", "decorators-legacy"] };
+
+/**
+ * Resolves `relSpec` against `dirPosix` and returns the matching project file
+ * only if it actually exists in `fileSet` — this existence check, not a
+ * leading-dot requirement, is what prevents fabricating an entry. A bare
+ * relative filename (e.g. "preload.js", as produced by `path.join(__dirname,
+ * "preload.js")`) is just as valid a spec here as "./preload.js"; both are
+ * relative to `dirPosix` either way.
+ */
+function resolveFromDir(dirPosix, relSpec, fileSet) {
+  if (typeof relSpec !== "string" || !relSpec.trim()) return null;
+  const base = path.posix.join(dirPosix, relSpec);
+  const candidates = [base, `${base}.js`, `${base}.ts`, `${base}.jsx`, `${base}.tsx`, `${base}.mjs`, `${base}.mts`];
+  for (const c of candidates) {
+    const norm = path.posix.normalize(c);
+    if (fileSet.has(norm)) return norm;
+  }
+  return null;
+}
+
+/**
+ * Next.js file-based routing: Pages Router (anything under "pages", API
+ * routes under "pages/api") and App Router (page/route/layout files nested
+ * anywhere under "app"). Pure path-convention matching — no parsing needed,
+ * and no ambiguity: a file either matches Next.js's documented convention or
+ * it doesn't.
+ */
+export function detectNextJsEntries(fileSet) {
+  const entries = [];
+  for (const file of fileSet) {
+    const pagesMatch = /^(?:src\/)?pages\/(.+)\.(jsx?|tsx?)$/.exec(file);
+    if (pagesMatch) {
+      const routePath = pagesMatch[1];
+      if (path.posix.basename(routePath).startsWith("_")) continue; // _app/_document/_error/_middleware are framework hooks, not routes
+      const kind = routePath.startsWith("api/") ? "nextjs-api-route" : "nextjs-page";
+      entries.push({ file, kind, detail: `Next.js ${kind === "nextjs-api-route" ? "API route" : "page"}: /${routePath}` });
+      continue;
+    }
+    const appMatch = /^(?:src\/)?app\/(.*\/)?(page|route|layout)\.(jsx?|tsx?)$/.exec(file);
+    if (appMatch) {
+      const kind = appMatch[2] === "route" ? "nextjs-route-handler" : appMatch[2] === "layout" ? "nextjs-layout" : "nextjs-page";
+      entries.push({ file, kind, detail: `Next.js App Router ${appMatch[2]}: /${appMatch[1] ?? ""}` });
+    }
+  }
+  return entries;
+}
+
+/**
+ * HTML entry points: `<script type="module" src="...">` tags in root-level
+ * HTML files — Vite's DEFAULT entry convention (used whenever a project does
+ * NOT set an explicit `build.rollupOptions.input`, which is the common case:
+ * verified against a real project during development, MITRI included). A
+ * root-relative src ("/src/main.jsx") resolves against the project root; a
+ * relative src ("./main.jsx") resolves against the HTML file's directory. An
+ * external URL (http(s)://, a bare specifier) is skipped, never guessed at.
+ */
+export function detectHtmlEntries(rootDir, fileSet) {
+  const entries = [];
+  let rootEntries;
+  try { rootEntries = fs.readdirSync(rootDir, { withFileTypes: true }); } catch { return entries; }
+
+  for (const entry of rootEntries) {
+    if (!entry.isFile() || !entry.name.endsWith(".html")) continue;
+    const relHtml = entry.name;
+    let html;
+    try { html = fs.readFileSync(path.join(rootDir, relHtml), "utf8"); } catch { continue; }
+
+    const scriptTagRe = /<script\b([^>]*)>/gi;
+    let tagMatch;
+    while ((tagMatch = scriptTagRe.exec(html))) {
+      const attrs = tagMatch[1];
+      const typeMatch = /\btype\s*=\s*["']([^"']+)["']/i.exec(attrs);
+      const srcMatch = /\bsrc\s*=\s*["']([^"']+)["']/i.exec(attrs);
+      if (!srcMatch || typeMatch?.[1]?.toLowerCase() !== "module") continue;
+      const src = srcMatch[1];
+      if (/^([a-z]+:)?\/\//i.test(src)) continue; // external URL, e.g. https://... or //cdn...
+
+      const dirPosix = src.startsWith("/") ? "." : path.posix.dirname(relHtml);
+      const spec = src.startsWith("/") ? `.${src}` : src;
+      const resolved = resolveFromDir(dirPosix, spec, fileSet);
+      if (resolved) entries.push({ file: resolved, kind: "html-module-entry", detail: `<script type="module"> in ${relHtml}` });
+    }
+  }
+  return entries;
+}
+
+/**
+ * Vite entry points: `build.rollupOptions.input` and `build.lib.entry` in
+ * vite.config.{js,ts,mjs,mts} at the project root. Verified by walking the
+ * real AST and anchoring on the literal enclosing key name (`rollupOptions`
+ * or `lib`) — never a bare "any object with an `input`/`entry` key."
+ */
+export function detectViteEntries(rootDir, fileSet) {
+  const entries = [];
+  for (const rel of ["vite.config.ts", "vite.config.js", "vite.config.mjs", "vite.config.mts"]) {
+    const abs = path.join(rootDir, rel);
+    if (!fs.existsSync(abs)) continue;
+    let ast;
+    try { ast = parse(fs.readFileSync(abs, "utf8"), BABEL_OPTS); } catch { continue; }
+
+    traverse(ast, {
+      ObjectProperty(p) {
+        const keyName = p.node.key?.name ?? p.node.key?.value;
+        if (keyName !== "input" && keyName !== "entry") return;
+        const enclosingProp = p.parentPath?.parentPath;
+        const enclosingKey = enclosingProp?.isObjectProperty?.() ? (enclosingProp.node.key?.name ?? enclosingProp.node.key?.value) : null;
+        const anchorMatches = (keyName === "input" && enclosingKey === "rollupOptions") || (keyName === "entry" && enclosingKey === "lib");
+        if (!anchorMatches) return;
+
+        const value = p.node.value;
+        const specs = [];
+        if (value.type === "StringLiteral") {
+          specs.push(value.value);
+        } else if (value.type === "ArrayExpression") {
+          for (const el of value.elements) if (el?.type === "StringLiteral") specs.push(el.value);
+        } else if (value.type === "ObjectExpression") {
+          for (const prop of value.properties) if (prop.value?.type === "StringLiteral") specs.push(prop.value.value);
+        }
+
+        for (const spec of specs) {
+          const resolved = resolveFromDir(".", spec, fileSet);
+          if (resolved) entries.push({ file: resolved, kind: "vite-entry", detail: `build.${enclosingKey}.${keyName} in ${rel}` });
+        }
+      },
+    });
+  }
+  return entries;
+}
+
+function resolvePreloadValue(valueNode, fileDirPosix, fileSet) {
+  if (valueNode.type === "StringLiteral") return resolveFromDir(fileDirPosix, valueNode.value, fileSet);
+  if (valueNode.type === "CallExpression") {
+    const callee = valueNode.callee;
+    const isPathJoinOrResolve = callee?.type === "MemberExpression" && callee.object?.name === "path" &&
+      (callee.property?.name === "join" || callee.property?.name === "resolve");
+    if (!isPathJoinOrResolve) return null;
+    const args = valueNode.arguments ?? [];
+    if (!args.some((a) => a.type === "Identifier" && a.name === "__dirname")) return null; // only the well-known, verifiable pattern
+    const literalParts = args.filter((a) => a.type === "StringLiteral").map((a) => a.value);
+    if (!literalParts.length) return null;
+    return resolveFromDir(fileDirPosix, literalParts.join("/"), fileSet);
+  }
+  return null;
+}
+
+/**
+ * Electron preload entries: `new BrowserWindow({ webPreferences: { preload: ... } })`.
+ * Only resolves the preload path when it's a plain string or the well-known
+ * `path.join(__dirname, "...")`/`path.resolve(__dirname, "...")` pattern —
+ * any other expression shape (a variable, a computed path) is left
+ * unresolved rather than guessed at.
+ */
+export function detectElectronPreloadEntries(rootDir, files, fileSet) {
+  const entries = [];
+  for (const f of files) {
+    const relFile = f.file.split(path.sep).join("/");
+    if (!/\.(js|ts|mjs|cjs|mts|cts)$/.test(relFile)) continue;
+    let raw;
+    try { raw = fs.readFileSync(path.join(rootDir, relFile), "utf8"); } catch { continue; }
+    if (!raw.includes("BrowserWindow") || !raw.includes("preload")) continue; // cheap pre-filter, not the actual verification
+    let ast;
+    try { ast = parse(raw, BABEL_OPTS); } catch { continue; }
+    const fileDirPosix = path.posix.dirname(relFile);
+
+    traverse(ast, {
+      NewExpression(p) {
+        if (p.node.callee?.name !== "BrowserWindow") return;
+        const optsArg = p.node.arguments?.[0];
+        if (optsArg?.type !== "ObjectExpression") return;
+        const webPrefsProp = optsArg.properties.find((pr) => pr.key?.name === "webPreferences" || pr.key?.value === "webPreferences");
+        const webPrefsObj = webPrefsProp?.value;
+        if (webPrefsObj?.type !== "ObjectExpression") return;
+        const preloadProp = webPrefsObj.properties.find((pr) => pr.key?.name === "preload" || pr.key?.value === "preload");
+        if (!preloadProp) return;
+        const resolved = resolvePreloadValue(preloadProp.value, fileDirPosix, fileSet);
+        if (resolved) entries.push({ file: resolved, kind: "electron-preload", detail: `BrowserWindow webPreferences.preload in ${relFile}` });
+      },
+    });
+  }
+  return entries;
+}
+
+/**
+ * Tooling config files: entry points read directly by an external tool
+ * (a test runner, a process manager) rather than imported by application
+ * code. Without registering these, everything they alone pull in (e2e specs,
+ * fixture helpers, deploy config) reads as unreachable "dead code" when it
+ * isn't — it just belongs to a different runtime context than the app's own
+ * entry points. Pure filename-convention matching (same verification model
+ * as detectHtmlEntries: the file existing at its conventional path/name IS
+ * the check) — once registered, the existing import-graph traversal already
+ * follows whatever these files themselves import.
+ */
+const TOOLING_CONFIG_PATTERNS = [
+  { re: /^playwright\.config\.(js|ts|mjs|cjs|mts|cts)$/, kind: "playwright-config", label: "Playwright config" },
+  { re: /^jest\.config\.(js|ts|mjs|cjs|json)$/, kind: "jest-config", label: "Jest config" },
+  { re: /^vitest\.config\.(js|ts|mjs|cjs|mts|cts)$/, kind: "vitest-config", label: "Vitest config" },
+  { re: /^cypress\.config\.(js|ts|mjs|cjs)$/, kind: "cypress-config", label: "Cypress config" },
+  { re: /^ecosystem\.config\.(js|cjs)$/, kind: "pm2-ecosystem", label: "PM2 ecosystem config" },
+];
+
+export function detectToolingConfigEntries(fileSet) {
+  const entries = [];
+  for (const file of fileSet) {
+    if (file.includes("/")) continue; // these conventions are always project-root files
+    for (const { re, kind, label } of TOOLING_CONFIG_PATTERNS) {
+      if (re.test(file)) entries.push({ file, kind, detail: `${label} — read directly by its tool, not imported by app code` });
+    }
+  }
+  return entries;
+}
+
+/** Runs every framework detector and returns the combined, deduplicated entry list. */
+export function detectFrameworkEntries(rootDir, files, fileSet) {
+  const all = [
+    ...detectNextJsEntries(fileSet),
+    ...detectHtmlEntries(rootDir, fileSet),
+    ...detectViteEntries(rootDir, fileSet),
+    ...detectElectronPreloadEntries(rootDir, files, fileSet),
+    ...detectToolingConfigEntries(fileSet),
+  ];
+  const seen = new Set();
+  return all.filter((e) => {
+    const key = `${e.file}::${e.kind}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/src/core/gates.js

@@ -0,0 +1,209 @@
+/**
+ * gates.js — the general-purpose deterministic verification gate runner.
+ *
+ * G1-G3 originally lived only inside integrate.js's merge-conflict pipeline.
+ * This module is the single implementation; integrate.js now calls into it
+ * so the merge-resolution and fix-engine pipelines can never drift apart.
+ *
+ * DESIGN RULE (unchanged from integrate.js): a gate failure never gets
+ * silently dropped — every gate result is returned, and the caller decides
+ * status ("rejected-by-gate" etc.) from the full list.
+ */
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parseJsFile } from "./parser.js";
+import { sanitizeRelPath, isProtectedPath } from "./security.js";
+import { diffWorkspace } from "./workspace.js";
+import { buildScoredGraph } from "./intelligence.js";
+import { diffGraphs } from "./regression.js";
+import { detectPackageManager } from "./graph.js";
+import { platformCommand } from "./proc.js";
+
+/** Parse source held in memory by round-tripping through a temp file. */
+export function parseSource(source, label) {
+  const tmp = path.join(os.tmpdir(), `mapd-src-${Date.now()}-${Math.random().toString(36).slice(2)}.js`);
+  fs.writeFileSync(tmp, source);
+  try { return parseJsFile(tmp, label); }
+  finally { fs.rmSync(tmp, { force: true }); }
+}
+
+/**
+ * G1: the source parses cleanly (zero Babel recovery errors).
+ * G2: exports are a superset of `requiredExports` (when supplied).
+ * G3: top-level function names are a superset of `requiredFunctions` (when supplied),
+ *     ignoring anonymous functions.
+ * G4 (optional, best-effort): a resolvable test command passes in `cwd`. Skipped
+ *     (never faked) when no test command can be resolved.
+ *
+ * Returns the same `[{gate, passed, missing?}]` shape integrate.js's
+ * verifyProposal has always returned, so existing gate-name strings and
+ * consumers (review queue, CLI output) are unaffected by this refactor.
+ */
+export function runStandardGates({ source, label, requiredExports, requiredFunctions, cwd, testCommand } = {}) {
+  const gates = [];
+  const p = parseSource(source, label);
+
+  gates.push({ gate: "G1-parses-cleanly", passed: p.parsed && p.parseErrors === 0 });
+
+  if (requiredExports) {
+    const got = new Set(p.exports);
+    const missing = requiredExports.filter((e) => !got.has(e));
+    gates.push({ gate: "G2-export-union-preserved", passed: missing.length === 0, missing });
+  }
+  if (requiredFunctions) {
+    const got = new Set(p.functions.map((f) => f.name));
+    const missing = requiredFunctions.filter((f) => !got.has(f) && !f.startsWith("<anon"));
+    gates.push({ gate: "G3-function-union-preserved", passed: missing.length === 0, missing });
+  }
+  if (testCommand && cwd) {
+    gates.push(runTestGate(testCommand, cwd));
+  }
+  return gates;
+}
+
+/** G4: best-effort — run a resolvable test command in an isolated cwd. Never fabricates a result. */
+function runTestGate(testCommand, cwd) {
+  try {
+    const pc = platformCommand(testCommand[0], testCommand.slice(1), { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 120_000 });
+    execFileSync(pc.file, pc.args, pc.options);
+    return { gate: "G4-tests-pass", passed: true };
+  } catch (e) {
+    return {
+      gate: "G4-tests-pass", passed: false,
+      exitCode: e.status ?? null,
+      stderr: (e.stderr ?? "").toString().slice(0, 4000),
+      stdout: (e.stdout ?? "").toString().slice(0, 4000),
+    };
+  }
+}
+
+/**
+ * Registry seam: additional gates (e.g. a project-specific policy gate) can be
+ * added here without touching integrate.js or fix.js call sites.
+ */
+export const GATES = {
+  G1: "G1-parses-cleanly",
+  G2: "G2-export-union-preserved",
+  G3: "G3-function-union-preserved",
+  G4: "G4-tests-pass",
+};
+
+/* ------------------------------------------------------------------------ *
+ * General verification pipeline gates (fix.js / mcp / chat).
+ *
+ * These are NAMED DIFFERENTLY from integrate.js's merge-specific G1/G2/G3
+ * above (which stay untouched for backward compatibility with
+ * tests/integrate.test.js). These three implement the spec's general
+ * definitions:
+ *   FIX-G1  patch & structural safety
+ *   FIX-G2  project correctness (available project scripts: test/lint/typecheck)
+ *   FIX-G3  Map'd regression verification (remap, compare confidence/orphans)
+ * ------------------------------------------------------------------------ */
+
+/** FIX-G1: every proposed file is safe to write, parses, and nothing unexpected changed. */
+export function runPatchSafetyGate({ ws, patch, forbiddenPaths = [], maxFileSizeBytes = 1_000_000 }) {
+  const issues = [];
+  for (const [relFile, newSource] of Object.entries(patch)) {
+    try {
+      sanitizeRelPath(ws.dir, relFile);
+    } catch (e) {
+      issues.push(`${relFile}: ${e.message}`);
+      continue;
+    }
+    if (isProtectedPath(relFile, forbiddenPaths)) {
+      issues.push(`${relFile}: protected path, refusing to modify`);
+      continue;
+    }
+    if (Buffer.byteLength(newSource, "utf8") > maxFileSizeBytes) {
+      issues.push(`${relFile}: exceeds maxFileSizeBytes (${maxFileSizeBytes})`);
+    }
+    const parsed = parseSource(newSource, relFile);
+    if (!parsed.parsed || parsed.parseErrors > 0) {
+      issues.push(`${relFile}: does not parse cleanly`);
+    }
+  }
+  const changed = diffWorkspace(ws);
+  const allowed = new Set(Object.keys(patch));
+  const unexpected = changed.filter((f) => !allowed.has(f));
+  if (unexpected.length) issues.push(`unexpected files changed: ${unexpected.join(", ")}`);
+
+  return { gate: "FIX-G1-patch-safety", passed: issues.length === 0, issues };
+}
+
+function runPackageManagerScript(cwd, manager, args, timeoutMs) {
+  try {
+    const pc = platformCommand(manager, args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs });
+    execFileSync(pc.file, pc.args, pc.options);
+    return { script: `${manager} ${args.join(" ")}`, passed: true };
+  } catch (e) {
+    return {
+      script: `${manager} ${args.join(" ")}`, passed: false,
+      exitCode: e.status ?? null,
+      stderr: (e.stderr ?? "").toString().slice(0, 4000),
+      stdout: (e.stdout ?? "").toString().slice(0, 4000),
+    };
+  }
+}
+
+/**
+ * FIX-G2: run whichever of test/lint/typecheck scripts the project actually
+ * defines in package.json. Never assumes a script exists — detects it. Also
+ * never assumes npm: detects the actual package manager from the project's
+ * lockfile (pnpm-lock.yaml / yarn.lock / package-lock.json / bun.lockb),
+ * falling back to npm only when no lockfile is present at all.
+ */
+export function runProjectCorrectnessGate({ cwd, pkg, runTests = true, runLint = true, runTypecheck = true, timeoutMs = 120_000 }) {
+  const scripts = pkg?.scripts ?? {};
+  const { manager } = detectPackageManager(cwd);
+  const checks = [];
+  if (runTests && scripts.test) checks.push(runPackageManagerScript(cwd, manager, ["test"], timeoutMs));
+  if (runLint && scripts.lint) checks.push(runPackageManagerScript(cwd, manager, ["run", "lint"], timeoutMs));
+  const typecheckScript = scripts.typecheck ? "typecheck" : scripts["type-check"] ? "type-check" : null;
+  if (runTypecheck && typecheckScript) checks.push(runPackageManagerScript(cwd, manager, ["run", typecheckScript], timeoutMs));
+
+  if (!checks.length) return { gate: "FIX-G2-project-correctness", passed: true, skipped: true, checks: [] };
+  return { gate: "FIX-G2-project-correctness", passed: checks.every((c) => c.passed), checks };
+}
+
+/**
+ * FIX-G3: remap the isolated workspace and compare against the pre-fix graph
+ * (and baseline, when available) — confidence must not newly regress, no new
+ * high-severity findings, AND — when a target finding and a usable baseline
+ * are both available — the finding's exact condition (same kind + detail)
+ * must no longer reproduce when diffed against the baseline. A patch that
+ * leaves the original problem in place fails this gate; the model's own
+ * claim of success is never taken as evidence.
+ */
+export function runRegressionGate({ ws, preFixGraph, baseline, targetFinding, confidenceTolerance = 0.02 }) {
+  const postGraph = buildScoredGraph(ws.dir);
+  const deltaConfidence = Number((postGraph.repoConfidence - preFixGraph.repoConfidence).toFixed(3));
+  const newOrphans = postGraph.orphans.filter((o) => !preFixGraph.orphans.includes(o));
+  const introduced = diffGraphs(preFixGraph, postGraph).filter((f) => f.kind !== "workflow-added");
+  const newHighSeverity = introduced.filter((f) => f.severity === "high");
+
+  let targetResolved = null;
+  let targetStillFailing = false;
+  if (baseline && targetFinding?.kind && targetFinding?.detail) {
+    const vsBaseline = diffGraphs(baseline, postGraph);
+    targetStillFailing = vsBaseline.some((f) => f.kind === targetFinding.kind && f.detail === targetFinding.detail);
+    targetResolved = { resolved: !targetStillFailing, remainingFindings: vsBaseline.length };
+  }
+
+  const passed = deltaConfidence >= -confidenceTolerance && newHighSeverity.length === 0 && !targetStillFailing;
+  return {
+    gate: "FIX-G3-mapd-regression", passed,
+    deltaConfidence, newOrphans, newHighSeverity, targetResolved,
+  };
+}
+
+/** Convenience: run all three general-pipeline gates for one fix attempt. */
+export function runFixGates({ ws, patch, forbiddenPaths, maxFileSizeBytes, pkg, cwd, runTests, runLint, runTypecheck, preFixGraph, baseline, targetFinding }) {
+  const g1 = runPatchSafetyGate({ ws, patch, forbiddenPaths, maxFileSizeBytes });
+  if (!g1.passed) return [g1]; // no point running tests/regression on an unsafe patch
+  const g2 = runProjectCorrectnessGate({ cwd: cwd ?? ws.dir, pkg, runTests, runLint, runTypecheck });
+  const g3 = runRegressionGate({ ws, preFixGraph, baseline, targetFinding });
+  return [g1, g2, g3];
+}