replume-cli 0.2.6 → 0.2.10

package/dist/cli.js

@@ -358,14 +358,14 @@ function cliEnv() {
   return { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: process.env.HOME, DOCKER_CONFIG: process.env.DOCKER_CONFIG };
 }
 function dockerCli(binary, args, timeoutMs) {
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     const child = spawn(binary, args, { env: cliEnv(), stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "", stderr = "", settled = false, timedOut2 = false, notFound = false;
     const done = (code2) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve17({ code: code2, stdout, stderr, timedOut: timedOut2, notFound });
+      resolve18({ code: code2, stdout, stderr, timedOut: timedOut2, notFound });
     };
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -503,7 +503,7 @@ async function runDockerScenario(input) {
     await cp(input.root, staged, { recursive: true, filter: (path) => basename(path) !== ".git" });
     if (process.getuid?.() === 0) await chmod(temp, 493);
     const args = buildDockerRunArgs({ name, image: input.image ?? DEFAULT_DOCKER_IMAGE, source: staged, command: input.command, labels: input.labels, limits: input.limits });
-    return await new Promise((resolve17) => {
+    return await new Promise((resolve18) => {
       const child = spawn(binary, args, { env: cliEnv(), stdio: ["ignore", "pipe", "pipe"] });
       const marker = `${commandStartMarker(name)}
 `;
@@ -516,7 +516,7 @@ async function runDockerScenario(input) {
         const endLine = END_LINE(name).exec(stderr);
         if (endLine) stderr = stderr.replace(endLine[0], "");
         const oomKills = endLine ? Number(endLine[1] ?? 0) : null;
-        resolve17({ stdout, stderr, exitCode, timedOut: timedOut2, durationMs: Math.round(performance2.now() - started), oomKills });
+        resolve18({ stdout, stderr, exitCode, timedOut: timedOut2, durationMs: Math.round(performance2.now() - started), oomKills });
       };
       const expire = (note) => async () => {
         timedOut2 = true;
@@ -1397,7 +1397,7 @@ function commitGateMessage(s, testCommand, verbs) {
 import { createHash as createHash3 } from "crypto";
 import { execFileSync as execFileSync7 } from "child_process";
 import { lstatSync as lstatSync3, readFileSync as readFileSync10, realpathSync, statSync } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve2, sep } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve3, sep } from "path";
 import { homedir, tmpdir as tmpdir3 } from "os";
 
 // src/core/glob.ts
@@ -1442,16 +1442,22 @@ import { existsSync as existsSync4, mkdirSync as mkdirSync2, mkdtempSync, readFi
 import { tmpdir as tmpdir2 } from "os";
 import { join as join4, posix } from "path";
 var MAX_ASKED = 5;
-var VERB = "rename[sd]?|renaming|move[sd]?|moving|update[sd]?|updating|change[sd]?|changing|edit(?:s|ed)?|modify|modif(?:ies|ied)|split|add(?:s|ed)?|replace[sd]?|rewrite|adjust|switch|reorgani[sz]e|regenerate|refresh|convert|extend|delete|remove";
-var OBJECT = "tests?|test files?|test cases?|snapshots?|specs?|assertions?|expectations?";
-var ASKS = new RegExp(`\\b(?:${VERB})\\b(?:[^.!?\\n]|\\.(?=\\S)){0,80}?\\b(?:${OBJECT})\\b(?!\\s+(?:pass|passes|passing|green|run|runs|succeed|succeeds|work))`, "i");
+var VERB = "rename[sd]?|renaming|move[sd]?|moving|update[sd]?|updating|change[sd]?|changing|edit(?:s|ed)?|modify|modif(?:ies|ied)|split|add(?:s|ed)?|replace[sd]?|replacing|rewrite[sn]?|rewrote|rewriting|adjust|switch|reorgani[sz]e|regenerate|refresh|convert|extend|delete|remove|revise[sd]?|revising|refactor(?:s|ed|ing)?|migrate[sd]?|migrating|port";
+var OBJECT = "tests?|test files?|test cases?|test suites?|snapshots?|specs?|assertions?|expectations?";
+var ASKS = new RegExp(`\\b(?:${VERB})\\b(?:[^.!?\\n]|\\.(?=\\S)){0,80}?\\b(?:${OBJECT})\\b(?!\\s+(?:(?:must|should|still|all|will|can|to|keep|keeps|continue|continues|need|needs)\\s+){0,3}(?:pass|passes|passing|green|run|runs|succeed|succeeds|work))`, "i");
+var DONE_FORM = "updated|updating|rewritten|rewriting|replaced|replacing|changed|changing|edited|editing|renamed|renaming|moved|moving|adjusted|adjusting|modified|modifying|revised|revising|migrated|migrating|change";
+var ASKS_PASSIVE = new RegExp(`\\b(?:${OBJECT})\\b(?:[^.!?\\n,;]){0,40}?\\b(?:must|should|need|needs|has to|have to|ought to|will|to)\\s+(?:also\\s+)?(?:be\\s+)?(?:${DONE_FORM})\\b`, "i");
+var CHANGE_VERB = "update[sd]?|updating|rewrite[sn]?|rewrote|rewriting|replace[sd]?|replacing|change[sd]?|changing|edit(?:s|ed)?|modify|adjust|revise[sd]?|revising|refactor(?:s|ed|ing)?|migrate[sd]?|migrating|port";
+var WHOLE_SUITE = new RegExp(`\\b(?:${CHANGE_VERB})\\b(?:\\s+(?:all|every|each|the|of|existing|its|their|our|affected|relevant|these|those|remaining))*\\s+(?:tests|test files|test suite)\\b(?!\\s+(?:that|which|for|of|in)\\b)|\\b(?:${CHANGE_VERB})\\b[^.!?\\n;]{0,60}?\\bin\\s+(?:all\\s+|every\\s+|each\\s+)?(?:of\\s+)?(?:the\\s+)?tests\\b|\\b(?:the\\s+|all\\s+|every\\s+)?tests\\s+(?:must|should|need|needs|have to)\\s+(?:also\\s+)?(?:be\\s+)?(?:${DONE_FORM})\\b`, "i");
+var FOLDER_TOKEN = /(?:^|[\s"'`(<[])((?:\.\/)?[\w@.-]+(?:\/[\w@.-]+)*\/?)(?=$|[\s"'`)>\],;:!?]|\.(?:\s|$))/g;
 var VERB_ONLY = new RegExp(`\\b(?:${VERB})\\b`, "i");
 var PATH = /(?:^|[\s"'`(<[])((?:\.{0,2}\/)?(?:[\w@.-]+\/)*[\w@.-]+\.[A-Za-z0-9]+)(?=$|[\s"'`)>\],;:!?]|\.(?:\s|$))/g;
 var STOP = /* @__PURE__ */ new Set(["test", "tests", "file", "files", "case", "cases", "snapshot", "snapshots", "that", "this", "with", "from", "into", "each", "every", "where", "which", "should", "would", "rule", "both", "them", "they", "their", "what", "when", "make", "pass", "update", "change", "rename", "move", "split", "add", "and", "the", "for"]);
 var RUNS_TESTS = /\b(?:run|runs|running|rerun|re-run|execute|executing)\s+(?:(?!and\b|then\b)\w+\s+){0,3}?(?:tests?|specs?)\b|\b(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?test\b/gi;
 var NOUN_CHANGE = /\b(?:that|this|the|a|an|each|every|your|my|these|those|one|other)\s+(?:changes?|updates?|edits?|moves?|split|rename|replacement|switch|refresh|rewrite)\b(?!\s+(?:to|in|on|of)\b)/gi;
 var NEW_TEST = /\b(?:add|adds|adding|create|creates|creating|write|writes|writing)\s+(?:a\s+|an\s+|some\s+)?new\s+(?:test|spec)(?:s|\s+files?|\s+cases?)?\b/gi;
-var requestText = (s) => s.replace(NEW_TEST, " ").replace(RUNS_TESTS, " ").replace(NOUN_CHANGE, " ");
+var LEFT_ALONE = new RegExp(`\\b(?:leave|leaves|leaving|keep|keeps|keeping|without\\s+(?:changing|touching|updating|editing)|(?:do\\s+not|don['\u2019]?t|never|not)\\s+(?:\\w+\\s+){0,2}?(?:change|touch|edit|update|modify))\\b[^.!?\\n;,]{0,30}?\\b(?:${OBJECT})\\b`, "gi");
+var requestText = (s) => s.replace(LEFT_ALONE, " ").replace(NEW_TEST, " ").replace(RUNS_TESTS, " ").replace(NOUN_CHANGE, " ");
 var CLAUSE_SPLIT = /(?:[;,:]|\s+but\s+|\s+and\s+then\s+|\s+then\s+|\s+instead\s+)/i;
 var NEG = /\b(?:do\s+not|don['’]?t|dont|never|not|no\s+need\s+to|without|avoid|leave|keep)\b(?:\s+\w+){0,3}\s*$/i;
 var FIRST_VERB = new RegExp(`\\b(?:${VERB})\\b`, "i");
@@ -1505,7 +1511,7 @@ function testEditsAskedFor(task, repoRoot2, files, rev) {
     const before = prev;
     prev = { named: pathsIn2(s).filter((p) => tests.includes(p)), negated };
     const refersBack = !named.length && !!before && !before.negated && before.named.length > 0 && before.named.length <= MAX_ASKED && REFERS_BACK.test(request) && VERB_ONLY.test(request);
-    const asks = ASKS.test(request) || named.length > 0 && VERB_ONLY.test(s) || refersBack;
+    const asks = ASKS.test(request) || ASKS_PASSIVE.test(request) || named.length > 0 && VERB_ONLY.test(s) || refersBack;
     if (!asks) continue;
     const had = out.paths.length;
     for (const p of named) add2(p, "the task names it");
@@ -1522,6 +1528,11 @@ function testEditsAskedFor(task, repoRoot2, files, rev) {
         const src = imports(f).find((x) => sources2.includes(x));
         if (src) add2(f, `it tests ${src}, which the task names`);
       }
+    if (new RegExp(`\\b(?:${OBJECT})\\b`, "i").test(request))
+      for (const d of foldersNamedIn(task, all)) {
+        const ref = new RegExp(`(?:^|[^\\w.-])${d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/|\\b${d.replace(/\//g, ".").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.\\w|\\bfrom\\s+${d.replace(/\//g, ".").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s+import\\b|/${posix.basename(d).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/`);
+        for (const f of tests) if (ref.test(text(f))) add2(f, `it names ${d}, which the task names`);
+      }
     const words6 = (s.toLowerCase().match(/[a-z]{5,}/g) ?? []).filter((w) => !STOP.has(w));
     if (/\btests?\b/i.test(request) && words6.length)
       for (const f of tests) {
@@ -1537,10 +1548,89 @@ function testEditsAskedFor(task, repoRoot2, files, rev) {
       }
     if (out.paths.length === had && refersBack)
       for (const p of before.named) add2(p, `the task names it in the sentence before "${whole2.slice(0, 40)}"`);
+    if (!out.paths.length && WHOLE_SUITE.test(request) && tests.length <= MAX_ASKED)
+      for (const f of tests) add2(f, WHOLE_SUITE_WHY);
   }
   if (out.paths.length > MAX_ASKED) return { paths: [], why: {} };
   return out;
 }
+var WHOLE_SUITE_WHY = "the task asks to change the tests as a whole";
+function foldersNamedIn(task, all) {
+  const out = /* @__PURE__ */ new Set();
+  const add2 = (name) => {
+    const d = posix.normalize(name.replace(/^\.\//, "")).replace(/\/+$/, "");
+    if (d && d !== "." && !d.startsWith("..") && all.some((f) => f.startsWith(`${d}/`))) out.add(d);
+  };
+  for (const m of task.matchAll(FOLDER_TOKEN)) if (m[1].includes("/")) add2(m[1]);
+  for (const m of task.matchAll(/\b([\w@.-]+)`?\s+(?:package|folder|directory)\b/gi)) add2(m[1]);
+  for (const m of task.matchAll(/\b(?:package|folder|directory)\s+`?([\w@./-]+)/gi)) add2(m[1]);
+  return [...out];
+}
+var DELETE_VERB = /\b(?:delete[sd]?|deleting|remove[sd]?|removing)\s+/gi;
+var LEAD_WORDS = /^(?:the|this|that|these|those|old|legacy|whole|entire|empty|original|now-empty|file|files|folder|folders|directory|directories|dir|dirs|package|packages|module|modules)\s+/i;
+var TAIL_WORDS = /\s+(?:package|packages|folder|folders|directory|directories|dir|dirs|module|modules|file|files|too|also|afterwards|entirely|completely|as well)$/i;
+var CODE_EXT = /\.(?:py|js|mjs|cjs|jsx|ts|tsx|rb|go|rs|java|kt|php)$/;
+function deletionsAskedFor(task, repoRoot2, tracked_, rev) {
+  const all = tracked_ ?? tracked(repoRoot2, rev);
+  const files = /* @__PURE__ */ new Set();
+  const dirs = /* @__PURE__ */ new Set();
+  const deletable = (f) => !isTestFile(f) && !isTestSupportFile(f) && !isSnapshot(f);
+  const resolve18 = (name) => {
+    const p = posix.normalize(name.replace(/^\.\//, "")).replace(/\/+$/, "");
+    if (!p || p === "." || p.startsWith("..") || p.startsWith("/") || /\s/.test(p)) return false;
+    if (all.includes(p)) {
+      if (deletable(p)) files.add(p);
+      return true;
+    }
+    const under = all.filter((f) => f.startsWith(`${p}/`));
+    if (under.length) {
+      const kept = under.filter(deletable);
+      if (kept.length) {
+        kept.forEach((f) => files.add(f));
+        if (kept.length === under.length) dirs.add(p);
+      }
+      return true;
+    }
+    const one = all.filter((f) => {
+      const b = posix.basename(f);
+      return b === p || b.replace(CODE_EXT, "") === p && CODE_EXT.test(b);
+    });
+    if (one.length === 1) {
+      if (deletable(one[0])) files.add(one[0]);
+      return true;
+    }
+    return false;
+  };
+  for (const whole2 of task.split(/(?<=[.!?])\s+|\n+/)) {
+    const s = withoutNegatedClauses(whole2).text;
+    for (const m of s.matchAll(DELETE_VERB)) {
+      const rest = s.slice(m.index + m[0].length).split(/[;:!?]|\.(?:\s|$)|\s+then\s+/)[0];
+      for (const raw6 of rest.split(/,|\s+and\s+/)) {
+        let t = raw6.replace(/[`"'*]/g, "").trim();
+        for (let prev = ""; prev !== t; ) {
+          prev = t;
+          t = t.replace(LEAD_WORDS, "").replace(TAIL_WORDS, "").trim();
+        }
+        if (!resolve18(t)) break;
+      }
+    }
+  }
+  return { files: [...files], dirs: [...dirs] };
+}
+var DELETIONS_FILE = "contracts/asked-deletions.json";
+function recordAskedDeletions(repoRoot2, contractId, asked) {
+  mkdirSync2(join4(repoRoot2, ".replume", "contracts"), { recursive: true });
+  writeFileSync(join4(repoRoot2, ".replume", DELETIONS_FILE), JSON.stringify({ contract_id: contractId, ...asked }));
+}
+function recordedAskedDeletions(repoRoot2, contractId) {
+  try {
+    const r = JSON.parse(readFileSync3(join4(repoRoot2, ".replume", DELETIONS_FILE), "utf8"));
+    const strings2 = (v2) => Array.isArray(v2) ? v2.filter((p) => typeof p === "string") : [];
+    return r.contract_id === contractId ? { files: strings2(r.files), dirs: strings2(r.dirs) } : null;
+  } catch {
+    return null;
+  }
+}
 var ASKED_FILE = "contracts/asked-tests.json";
 var FILE_TYPES = new Set("js jsx mjs cjs ts tsx py rb go rs java kt c h cc cpp hpp cs php swift scala sh bash zsh sql json jsonl yaml yml toml ini cfg conf env xml html htm css scss less md mdx rst txt csv tsv lock proto graphql vue svelte".split(" "));
 function recordAskedTests(repoRoot2, contractId, paths) {
@@ -1636,6 +1726,8 @@ function testFileOfFailing(repoRoot2, names3) {
 function pathsNamedInTask(task, repoRoot2) {
   const out = /* @__PURE__ */ new Set();
   for (const whole2 of task.split(/(?<=[.!?])\s+|\n+/)) {
+    for (const m of withoutNegatedClauses(whole2).text.matchAll(/\b(?:every|all|each)\b[^.!?\n]{0,60}?\bin\s+(?:the\s+)?([\w@.-]+)(?=[\s,;]|$)/gi))
+      if (!m[1].includes(".") && existsSync4(join4(repoRoot2, m[1]))) out.add(`${m[1]}/**`);
     for (const raw6 of withoutNegatedClauses(whole2).text.match(/[\w@.\-/*?]+/g) ?? []) {
       const token = raw6.replace(/^\.\//, "").replace(/[.,:;?]+$/, "");
       const dirLike = token.endsWith("/");
@@ -1981,11 +2073,11 @@ function captureCoverage(eventsFile, changedPaths, hooksConfigured = false) {
   }
   const compared = new Set(events.filter((e) => e.type === "command" && e.command && e.raw?.treeCompared === true).map((e) => e.command));
   const shell = events.filter((e) => (e.type === "command" || e.type === "tool_pre") && e.command && !compared.has(e.command));
-  const opaque = [...new Set(shell.filter((e) => unobservable(e.command)).map((e) => e.command))];
+  const opaque2 = [...new Set(shell.filter((e) => unobservable(e.command)).map((e) => e.command))];
   const unparsed = [...new Set(shell.filter((e) => !unobservable(e.command) && e.raw?.writeNote === "write target not parsed").map((e) => e.command))];
-  if (opaque.length)
+  if (opaque2.length)
     notSeen.push(
-      `${opaque.length} shell command${opaque.length === 1 ? "" : "s"} ran a script file or wrote to a path built at run time (e.g. \`${opaque[0].slice(0, 80)}\`); what ${opaque.length === 1 ? "it" : "they"} wrote is not observable by Replume's shell rules`
+      `${opaque2.length} shell command${opaque2.length === 1 ? "" : "s"} ran a script file or wrote to a path built at run time (e.g. \`${opaque2[0].slice(0, 80)}\`); what ${opaque2.length === 1 ? "it" : "they"} wrote is not observable by Replume's shell rules`
     );
   if (unparsed.length)
     notSeen.push(
@@ -2009,7 +2101,7 @@ function captureCoverage(eventsFile, changedPaths, hooksConfigured = false) {
     changedFilesLanded: changedPaths.filter((p) => landedPaths.has(p)).length,
     changedFilesAttemptedOnly: attemptedOnly.slice(0, SHOWN_PATHS),
     changedFilesNotSeen: unseen.slice(0, SHOWN_PATHS),
-    unobservableCommands: opaque.length + unparsed.length,
+    unobservableCommands: opaque2.length + unparsed.length,
     notSeen
   };
 }
@@ -2688,6 +2780,8 @@ var ERROR_CODES = {
   NO_COMMIT: "NO_COMMIT",
   STALE_REPORT: "STALE_REPORT",
   TASK_TEST_RED: "TASK_TEST_RED",
+  ASKED_DELETE_NOT_DONE: "ASKED_DELETE_NOT_DONE",
+  EXPECTATION_CHANGED: "EXPECTATION_CHANGED",
   SUITE_SHRANK: "SUITE_SHRANK",
   REQUIRED_CHECK_MISSING: "REQUIRED_CHECK_MISSING",
   JIRA_NOT_DONE: "JIRA_NOT_DONE",
@@ -2716,6 +2810,7 @@ var ERROR_CODES = {
   CHECK_FAILED: "CHECK_FAILED",
   CHECK_NOT_RUN: "CHECK_NOT_RUN"
 };
+var ASKED_SHELL_REWRITE = "a shell command that rewrites a test cannot be checked before it runs";
 function codeForReportReason(subject, reason, status) {
   const embedded = /^\[([A-Z][A-Z0-9_]+)\]\s/.exec(reason)?.[1];
   if (embedded && embedded in ERROR_CODES) return embedded;
@@ -2729,6 +2824,8 @@ function codeForReportReason(subject, reason, status) {
   if (/runner not found|test runner was not there|vitest: not found|jest: not found|command not found/.test(s)) return ERROR_CODES.RUNNER_NOT_FOUND;
   if (/zero tests|no tests collected|no tests ran/.test(s)) return ERROR_CODES.ZERO_TESTS;
   if (/task test still red/.test(s)) return ERROR_CODES.TASK_TEST_RED;
+  if (/the task asks to delete .* still there/.test(s)) return ERROR_CODES.ASKED_DELETE_NOT_DONE;
+  if (/an expected value (?:may have )?changed in /.test(s)) return ERROR_CODES.EXPECTATION_CHANGED;
   if (/still failed|stopped with .* after \d+ steers?/.test(s)) return ERROR_CODES.STOP_RETRIES_EXHAUSTED;
   if (/test.bypass|special.case/.test(s)) return ERROR_CODES.TEST_BYPASS;
   if (/bent to|states the bug|expected.*bug/.test(s)) return ERROR_CODES.TEST_BENT;
@@ -2747,7 +2844,7 @@ function codeForReportReason(subject, reason, status) {
   if (/runtime/.test(subject)) return status === "failed" ? ERROR_CODES.RUNTIME_FAILED : ERROR_CODES.RUNTIME_NOT_CHECKED;
   if (/not observed|no agent session/.test(s)) return /no agent session/.test(s) ? ERROR_CODES.NO_AGENT_SESSION : ERROR_CODES.CHANGE_NOT_OBSERVED;
   if (/no allow globs/.test(s)) return ERROR_CODES.SCOPE_UNSET;
-  if (/outside allow|new dependency|lockfile adds/.test(s)) return ERROR_CODES.SCOPE_EXTRA;
+  if (/outside allow|changed outside the task|new dependency|lockfile adds/.test(s)) return ERROR_CODES.SCOPE_EXTRA;
   if (/not pass with at least one test|output does not show|unconfirmed/.test(s)) return ERROR_CODES.TEST_UNCONFIRMED;
   if (/no commit/.test(s)) return ERROR_CODES.NO_COMMIT;
   if (/working tree changed after this report/.test(s)) return ERROR_CODES.STALE_REPORT;
@@ -2804,6 +2901,390 @@ function prefixCode(code2, message) {
   return /^\[[A-Z][A-Z0-9_]+\]\s/.test(message) ? message : `[${code2}] ${message}`;
 }
 
+// src/core/test-cases.ts
+function assertAliases(text) {
+  const out = /* @__PURE__ */ new Set();
+  const mod = String.raw`['"](?:node:)?assert(?:/strict)?['"]`;
+  for (const m of text.matchAll(new RegExp(String.raw`\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*${mod}\s*\)(?:\.strict)?`, "g"))) out.add(m[1]);
+  for (const m of text.matchAll(new RegExp(String.raw`\bimport\s+(?:\*\s+as\s+)?([A-Za-z_$][\w$]*)\s*(?:,\s*\{[^}]*\}\s*)?from\s*${mod}`, "g"))) out.add(m[1]);
+  for (const m of text.matchAll(new RegExp(String.raw`(?:\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*require\s*\(\s*${mod}\s*\)|\bimport\s*\{([^}]*)\}\s*from\s*${mod})`, "g")))
+    for (const part of (m[1] ?? m[2] ?? "").split(",")) {
+      const name = part.split(/\s*(?::|\bas\b)\s*/).pop()?.trim();
+      if (name && /^[A-Za-z_$][\w$]*$/.test(name)) out.add(name);
+    }
+  out.delete("assert");
+  return [...out];
+}
+var isPython = (path) => /\.py$/.test(path);
+function closing(s, open) {
+  const pairs = { "(": ")", "[": "]", "{": "}" };
+  const stack = [];
+  for (let i = open; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      for (i++; i < s.length && s[i] !== c; i++) if (s[i] === "\\") i++;
+      continue;
+    }
+    if (pairs[c]) stack.push(pairs[c]);
+    else if (c === stack.at(-1)) {
+      stack.pop();
+      if (!stack.length) return i;
+    }
+  }
+  return -1;
+}
+function splitTop(s, sep6) {
+  const out = [];
+  let at = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      for (i++; i < s.length && s[i] !== c; i++) if (s[i] === "\\") i++;
+      continue;
+    }
+    if ("([{".includes(c)) {
+      const end = closing(s, i);
+      if (end < 0) break;
+      i = end;
+      continue;
+    }
+    if (s.startsWith(sep6, i)) {
+      out.push(s.slice(at, i));
+      at = i + sep6.length;
+      i += sep6.length - 1;
+    }
+  }
+  out.push(s.slice(at));
+  return out.map((x) => x.trim()).filter(Boolean);
+}
+function norm(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      for (; j < s.length && s[j] !== c; j++) if (s[j] === "\\") j++;
+      out += `"${s.slice(i + 1, j)}"`;
+      i = j;
+    } else if (!/\s/.test(c)) out += c;
+  }
+  return out.replace(/,([)\]}])/g, "$1").replace(/;$/, "");
+}
+var inputKey = (s) => norm(s).replace(/^(?:[A-Za-z_$][\w$]*\.)+(?=[A-Za-z_$][\w$]*\()/, "");
+var substitute = (text, bind) => {
+  const names3 = Object.keys(bind);
+  if (!names3.length) return text;
+  return text.replace(new RegExp(`(?<![\\w$."'])(?:${names3.map((n3) => n3.replace(/\$/g, "\\$")).join("|")})(?![\\w$"'])`, "g"), (m) => bind[m]);
+};
+function rowsOf(list5) {
+  const body = list5.trim().replace(/^[[(]/, "").replace(/[\])]$/, "");
+  return splitTop(body, ",").map((row) => {
+    const r = row.replace(/^pytest\.param\(/, "(");
+    return /^[[(]/.test(r) ? splitTop(r.slice(1, closing(r, 0)), ",").filter((x) => !/^\w+\s*=/.test(x)) : [r];
+  });
+}
+function bindAll(params, rows2) {
+  return rows2.filter((r) => r.length >= params.length).map((r) => Object.fromEntries(params.map((n3, i) => [n3, r[i]])));
+}
+var LITERAL = /^(?:["'`]|-?\d|\[|\{|\(|True\b|False\b|None\b|true\b|false\b|null\b|undefined\b)/;
+var ordered = (a, b) => LITERAL.test(a.trim()) && !LITERAL.test(b.trim()) ? [b, a] : [a, b];
+var opaque = (s) => ({ input: `?${norm(s)}`, expected: "" });
+var resolve2 = (text, vars) => {
+  let out = text;
+  for (let n3 = 0; n3 < 4; n3++) {
+    const next = substitute(out, vars);
+    if (next === out) break;
+    out = next;
+  }
+  return out;
+};
+var IDENT = /(?<![\w$."'])[A-Za-z_$][\w$]*(?![\w$"'(])/g;
+var unbound = (text, params) => [...text.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g, "").matchAll(IDENT)].some((m) => params.has(m[0]));
+function dictRows(list5) {
+  return splitTop(list5.trim().slice(1, -1), ",").map((p) => splitTop(p, ":")).filter((p) => p.length === 2);
+}
+function pythonCases(text) {
+  const cases = [];
+  let read4 = true;
+  const lines = text.split("\n");
+  const moduleVars = {};
+  let localVars = {};
+  let pending = null;
+  let scope = null;
+  let fn = null;
+  const vars = () => ({ ...moduleVars, ...localVars });
+  const rowsFrom = (expr) => {
+    const items = /\.items\(\)$/.test(expr.trim());
+    const value = resolve2(expr.trim().replace(/\.items\(\)$/, ""), vars());
+    if (/^\{/.test(value)) return items ? dictRows(value) : null;
+    return /^[[(]/.test(value) ? rowsOf(value) : null;
+  };
+  const statement = (i) => {
+    let s = lines[i];
+    let last = i;
+    const open = (x) => {
+      let n3 = 0;
+      for (let k = 0; k < x.length; k++) {
+        const c = x[k];
+        if (c === '"' || c === "'") {
+          for (k++; k < x.length && x[k] !== c; k++) if (x[k] === "\\") k++;
+          continue;
+        }
+        if ("([{".includes(c)) n3++;
+        if (")]}".includes(c)) n3--;
+      }
+      return n3;
+    };
+    while (open(s) > 0 && last + 1 < lines.length) s += `
+${lines[++last]}`;
+    return { text: s, last };
+  };
+  const add2 = (left, right, raw6) => {
+    const binds = scope?.binds ?? [{}];
+    for (const b of binds) {
+      const v2 = (x) => resolve2(substitute(x, b), vars());
+      const whole2 = right === null ? v2(raw6) : `${v2(left)} ${v2(right)}`;
+      if (fn && unbound(whole2, new Set([...fn.params].filter((p) => !(p in b))))) {
+        read4 = false;
+        continue;
+      }
+      if (right === null) cases.push(opaque(whole2));
+      else {
+        const [a, e] = ordered(v2(left), v2(right));
+        cases.push({ input: inputKey(a), expected: norm(e) });
+      }
+    }
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line2 = lines[i];
+    if (!line2.trim() || line2.trim().startsWith("#")) continue;
+    const indent = line2.length - line2.trimStart().length;
+    if (scope && indent <= scope.indent) scope = null;
+    if (fn && indent <= fn.indent) {
+      fn = null;
+      localVars = {};
+    }
+    const st = statement(i);
+    const body = st.text.trim();
+    const param = /^@pytest\.mark\.parametrize\s*\(/.exec(body);
+    if (param) {
+      i = st.last;
+      const parts2 = splitTop(body.slice(param[0].length, closing(body, param[0].length - 1)), ",");
+      if (parts2.length < 2) {
+        read4 = false;
+        continue;
+      }
+      const names3 = /^[[(]/.test(parts2[0]) ? splitTop(parts2[0].slice(1, -1), ",").map((n3) => n3.replace(/["']/g, "")) : parts2[0].replace(/["']/g, "").split(",").map((n3) => n3.trim());
+      const rows2 = rowsFrom(parts2[1]);
+      if (!rows2) {
+        read4 = false;
+        continue;
+      }
+      pending = { names: names3, rows: rows2 };
+      continue;
+    }
+    const def = /^(?:async\s+)?def\s+\w+\s*\(/.exec(body);
+    if (def) {
+      i = st.last;
+      const params = splitTop(body.slice(def[0].length, closing(body, def[0].length - 1)), ",").map((p) => p.split(/[:=]/)[0].trim().replace(/^\*+/, "")).filter((p) => p && p !== "self" && p !== "cls");
+      fn = { indent, params: new Set(params) };
+      localVars = {};
+      if (pending) {
+        scope = { indent, binds: bindAll(pending.names, pending.rows) };
+        if (!scope.binds.length) read4 = false;
+      }
+      pending = null;
+      continue;
+    }
+    const loop2 = /^for\s+(.+?)\s+in\s+(.+?):\s*$/s.exec(body);
+    if (loop2) {
+      i = st.last;
+      const rows2 = rowsFrom(loop2[2]);
+      if (rows2) scope = { indent, binds: bindAll(loop2[1].replace(/[()]/g, "").split(",").map((n3) => n3.trim()), rows2) };
+      else if (/\bassert\b/.test(lines.slice(i + 1, i + 8).join("\n"))) read4 = false;
+      continue;
+    }
+    const assign = /^([A-Za-z_]\w*)\s*=(?!=)\s*(.+)$/s.exec(body);
+    if (assign) {
+      i = st.last;
+      (fn ? localVars : moduleVars)[assign[1]] = assign[2].trim();
+      continue;
+    }
+    const a = /^assert\s+(.*)$/s.exec(body);
+    if (a) {
+      i = st.last;
+      const expr = splitTop(a[1], ",")[0] ?? "";
+      const sides = splitTop(expr, "==");
+      if (sides.length === 2) add2(sides[0], sides[1], expr);
+      else add2("", null, expr);
+      continue;
+    }
+    const unit = /^self\.(assert\w+|fail\w*)\s*\(/.exec(body);
+    if (unit) {
+      i = st.last;
+      const args = splitTop(body.slice(unit[0].length, closing(body, unit[0].length - 1)), ",");
+      if (unit[1] === "assertEqual" && args.length >= 2) add2(args[0], args[1], "");
+      else add2("", null, body);
+      continue;
+    }
+    if (/\braises\s*\(|\bpytest\.(?:fail|approx|warns)\b/.test(body)) {
+      i = st.last;
+      add2("", null, body);
+      continue;
+    }
+    i = st.last;
+  }
+  return { cases, read: read4 && cases.length > 0 };
+}
+function jsCases(text, aliases) {
+  const cases = [];
+  let read4 = true;
+  if (/\.should\b|\bshould\(/.test(text)) read4 = false;
+  const helperParams = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/\bfunction\s+[\w$]*\s*\(([^)]*)\)|\b(?:const|let|var)\s+[\w$]+\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/g)) for (const p of (m[1] ?? m[2] ?? "").split(",")) {
+    const n3 = p.split("=")[0].trim();
+    if (n3) helperParams.add(n3);
+  }
+  const nameAlt = ["assert", ...aliases].map((n3) => n3.replace(/\$/g, "\\$")).join("|");
+  const CALL = new RegExp(`(?<![\\w$.])(?:expect|(${nameAlt})(?:\\.(\\w+))?)\\(`, "g");
+  const varsBefore = (at, offset) => {
+    const out = {};
+    for (const m of text.slice(0, at + offset).matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?!require\b|async\b|function\b|\()/g)) {
+      const start = m.index + m[0].length;
+      const rest = text.slice(start);
+      const stop2 = splitTop(rest.split("\n")[0], ";")[0];
+      if (stop2 && !/=>/.test(stop2)) out[m[1]] = /^[[{(]/.test(stop2) && closing(text, start) > 0 ? text.slice(start, closing(text, start) + 1) : stop2;
+    }
+    return out;
+  };
+  const scan = (body, binds, offset) => {
+    for (const m of body.matchAll(CALL)) {
+      const open = m.index + m[0].length - 1;
+      const end = closing(body, open);
+      if (end < 0) {
+        read4 = false;
+        continue;
+      }
+      const args = splitTop(body.slice(open + 1, end), ",");
+      let input = null, expected = null, whole2 = body.slice(m.index, end + 1);
+      if (m[0].startsWith("expect")) {
+        const chain = /^(?:\s*\.\s*\w+)*\s*\(/.exec(body.slice(end + 1));
+        const o = chain ? end + chain[0].length : -1;
+        const c = o > 0 ? closing(body, o) : -1;
+        if (c > 0) whole2 = body.slice(m.index, c + 1);
+        const matcher = chain?.[0].replace(/\s/g, "");
+        if (chain && c > 0 && args.length === 1 && /^\.(?:toBe|toEqual|toStrictEqual)\($/.test(matcher ?? "")) {
+          input = args[0];
+          expected = body.slice(o + 1, c);
+        }
+      } else if (m[2] && /^(?:equal|strictEqual|deepEqual|deepStrictEqual)$/.test(m[2]) && args.length >= 2) {
+        input = args[0];
+        expected = args[1];
+      }
+      const vars = varsBefore(m.index, offset);
+      for (const b of binds) {
+        const v2 = (x) => resolve2(substitute(x, b), vars);
+        const seen = input !== null && expected !== null ? `${v2(input)} ${v2(expected)}` : v2(whole2);
+        if (unbound(seen, new Set([...helperParams].filter((p) => !(p in b))))) {
+          read4 = false;
+          continue;
+        }
+        if (input !== null && expected !== null) {
+          const [a, e] = ordered(v2(input), v2(expected));
+          cases.push({ input: inputKey(a), expected: norm(e) });
+        } else cases.push(opaque(v2(whole2)));
+      }
+    }
+  };
+  const parametrized = [];
+  const rowsOfJs = (s) => /^\[/.test(s.trim()) ? rowsOf(s) : null;
+  for (const m of text.matchAll(/\b(?:test|it|describe)\.each\(/g)) {
+    const open = m.index + m[0].length - 1;
+    const end = closing(text, open);
+    const call2 = end > 0 ? /^\s*\(/.exec(text.slice(end + 1)) : null;
+    if (!call2) {
+      read4 = false;
+      continue;
+    }
+    const callOpen = end + 1 + call2[0].length - 1;
+    const callEnd = closing(text, callOpen);
+    const fn = callEnd > 0 ? /,\s*(?:async\s*)?\(\s*\[?([^)]*?)\]?\s*\)\s*=>\s*/.exec(text.slice(callOpen, callEnd)) : null;
+    const rows2 = fn ? rowsOfJs(resolve2(text.slice(open + 1, end), varsBefore(m.index, 0))) : null;
+    if (!fn || !rows2) {
+      read4 = false;
+      continue;
+    }
+    parametrized.push([m.index, callEnd]);
+    scan(text.slice(callOpen, callEnd), bindAll(fn[1].split(",").map((n3) => n3.trim()).filter(Boolean), rows2), callOpen);
+  }
+  for (const m of text.matchAll(/\bfor\s*\(\s*(?:const|let|var)\s*\[([^\]]+)\]\s+of\s+([^)]+?)\s*\)\s*\{/g)) {
+    const bodyOpen = m.index + m[0].length - 1;
+    const bodyEnd = closing(text, bodyOpen);
+    const entries = /^Object\.entries\((.+)\)$/.exec(m[2].trim());
+    const source = resolve2((entries?.[1] ?? m[2]).trim(), varsBefore(m.index, 0));
+    const rows2 = entries && /^\{/.test(source) ? dictRows(source) : rowsOfJs(source);
+    if (bodyEnd < 0 || !rows2) {
+      read4 = false;
+      continue;
+    }
+    parametrized.push([m.index, bodyEnd]);
+    scan(text.slice(bodyOpen, bodyEnd), bindAll(m[1].split(",").map((n3) => n3.trim()), rows2), bodyOpen);
+  }
+  let plain = text;
+  for (const [a, b] of parametrized) plain = plain.slice(0, a) + " ".repeat(b + 1 - a) + plain.slice(b + 1);
+  scan(plain, [{}], 0);
+  return { cases, read: read4 && cases.length > 0 };
+}
+function testCases(text, path) {
+  try {
+    return isPython(path) ? pythonCases(text) : /\.[cm]?[jt]sx?$/.test(path) ? jsCases(text, assertAliases(text)) : { cases: [], read: false };
+  } catch {
+    return { cases: [], read: false };
+  }
+}
+var CALLEE = /^([A-Za-z_$][\w$]*)(\(.*)$/s;
+function withRenamedCallees(before, after) {
+  const inputs = new Set(after.map((c) => c.input));
+  const map = /* @__PURE__ */ new Map();
+  for (const c of before) {
+    if (inputs.has(c.input)) continue;
+    const m = CALLEE.exec(c.input);
+    if (!m) continue;
+    const to = after.filter((x) => {
+      const n3 = CALLEE.exec(x.input);
+      return !!n3 && n3[2] === m[2] && n3[1] !== m[1];
+    }).map((x) => CALLEE.exec(x.input)[1]);
+    const names3 = [...new Set(to)];
+    if (names3.length !== 1 || after.some((x) => CALLEE.exec(x.input)?.[1] === m[1]) || before.some((x) => CALLEE.exec(x.input)?.[1] === names3[0])) continue;
+    if (map.has(m[1]) && map.get(m[1]) !== names3[0]) return before;
+    map.set(m[1], names3[0]);
+  }
+  if (!map.size) return before;
+  return before.map((c) => {
+    const m = CALLEE.exec(c.input);
+    return m && map.has(m[1]) ? { ...c, input: `${map.get(m[1])}${m[2]}` } : c;
+  });
+}
+function compareCases(before, after, path) {
+  const a = testCases(before, path), b = testCases(after, path);
+  if (!a.read || !b.read) return { kind: "other", changes: [] };
+  const was = withRenamedCallees(a.cases, b.cases);
+  if (!was.every((c) => b.cases.some((x) => x.input === c.input))) return { kind: "other", changes: [] };
+  const changes = [];
+  for (const c of was) {
+    const now = b.cases.filter((x) => x.input === c.input);
+    if (!now.some((x) => x.expected === c.expected)) changes.push({ input: c.input, from: c.expected, to: now[0].expected });
+  }
+  return { kind: changes.length ? "values" : "same", changes };
+}
+var sameInputsKept = (before, after, path) => compareCases(before, after, path).kind !== "other";
+function taskNamesValue(task, value) {
+  const bare = value.replace(/^"(.*)"$/, "$1");
+  if (!bare) return false;
+  const quoted = bare.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\bto\\s+[\`'"]?${quoted}[\`'"]?(?!\\w|\\.\\d)`, "i").test(task);
+}
+
 // src/core/rules.ts
 var PREFIX = "Replume:";
 var pick = (ctx, approve, auto) => ctx?.mode === "auto" ? auto : approve;
@@ -2820,7 +3301,7 @@ function expandHome(p) {
 function splitPaths(repoRoot2, paths) {
   const inside = [];
   const outside = [];
-  const root = resolve2(repoRoot2);
+  const root = resolve3(repoRoot2);
   let realRoot;
   const isOut = (rel3) => rel3 === "" || rel3.startsWith("..") || isAbsolute2(rel3);
   for (const raw6 of paths) {
@@ -2829,7 +3310,7 @@ function splitPaths(repoRoot2, paths) {
       outside.push(p);
       continue;
     }
-    const abs = isAbsolute2(p) ? resolve2(p) : resolve2(root, p);
+    const abs = isAbsolute2(p) ? resolve3(p) : resolve3(root, p);
     let rel3 = relative2(root, abs);
     if (isOut(rel3)) {
       if (realRoot === void 0) realRoot = realPathOf(root);
@@ -3085,7 +3566,7 @@ var isBlockDevice = (p) => /^\/dev\/(?:(?:s|h|v|xv)d[a-z]+[0-9]*|nvme[0-9]+n[0-9
 function substitutionBodies(src) {
   const text = src.replace(/<<(-?)[ \t]*(['"]?)([A-Za-z_][\w-]*)\2[^\n]*\n[\s\S]*?\n[ \t]*\3(?=\n|$)/g, "");
   const out = [];
-  const closing = (from) => {
+  const closing2 = (from) => {
     let depth = 0;
     for (let j = from; j < text.length; j++) {
       const c = text[j];
@@ -3125,7 +3606,7 @@ function substitutionBodies(src) {
       continue;
     }
     if (text[i + 1] === "(" && (c === "$" && text[i + 2] !== "(" || (c === "<" || c === ">") && !dq)) {
-      const end = closing(i + 1);
+      const end = closing2(i + 1);
       out.push(text.slice(i + 2, end));
       i = end;
     } else if (c === "`") {
@@ -3557,44 +4038,6 @@ function inlineWriteTargets(command, repoRoot2) {
   };
   return splitPaths(repoRoot2, [...literals2].filter((l) => !/^[a-z]+:\/\//i.test(l) && !l.endsWith("/")).map((l) => isAbsolute2(l) ? l : join12(repoRoot2, l))).inside.filter((p) => isFile(p) || /\/[^/]+\.[A-Za-z0-9]+$/.test(p));
 }
-function heredocFileWrites(command, repoRoot2) {
-  const lines = command.split("\n");
-  const out = [];
-  const word = String.raw`(?:"[^"\n]+"|'[^'\n]+'|[^\s<>;&|'"()$` + "`" + String.raw`]+)`;
-  const unq = (w) => w.replace(/^(['"])(.*)\1$/, "$2");
-  for (let i = 0; i < lines.length; i++) {
-    const m = /<<(-?)[ \t]*(['"]?)([A-Za-z_][\w-]*)\2/.exec(lines[i]);
-    if (!m) continue;
-    const strip = m[1] === "-";
-    const quoted = !!m[2];
-    const body = [];
-    let j = i + 1;
-    for (; j < lines.length; j++) {
-      if ((strip ? lines[j].replace(/^\t+/, "") : lines[j]) === m[3]) break;
-      body.push(strip ? lines[j].replace(/^\t+/, "") : lines[j]);
-    }
-    const header = lines[i];
-    const closed = j < lines.length;
-    const skipTo = j;
-    const pre = header.slice(0, m.index).split(/&&|\|\||;/).pop();
-    const post = header.slice(m.index + m[0].length).split(/&&|\|\||;/)[0];
-    i = skipTo;
-    if (!closed || /<<|\|/.test(pre + post)) continue;
-    if (!quoted && /[$`\\]/.test(body.join("\n"))) continue;
-    const seg = `${pre} ${post}`.trim();
-    let target = null;
-    let cm;
-    if ((cm = new RegExp(String.raw`^cat\s*>\s*(${word})\s*$|^cat\s*$`).exec(pre.trim())) && (cm[1] || (cm = new RegExp(String.raw`^>\s*(${word})\s*$`).exec(post.trim())))) target = unq(cm[1]);
-    else if ((cm = new RegExp(String.raw`^tee\s+(${word})\s*$`).exec(seg)) && !cm[1].startsWith("-")) target = unq(cm[1]);
-    if (!target || /[*?[\]{}~]/.test(target)) continue;
-    const abs = resolve2(repoRoot2, target);
-    const rel3 = relative2(resolve2(repoRoot2), abs);
-    if (!rel3 || rel3.startsWith("..") || isAbsolute2(rel3)) continue;
-    out.push({ path: normalizeRel(rel3.split(sep).join("/")), content: body.length ? `${body.join("\n")}
-` : "" });
-  }
-  return out.filter((w) => out.filter((x) => x.path === w.path).length === 1);
-}
 function npmPkgKeys(command) {
   const keys2 = [];
   for (const { words: w } of commandSegments(command)) {
@@ -3618,7 +4061,7 @@ var outOfScopeEdit = (a, ctx) => {
   }
   const allow = ctx.contract?.allow ?? [];
   if (!ctx.contract || allow.length === 0) return null;
-  const outside = touched.inside.filter((p) => !matchesAny(p, allow) && !p.startsWith(".replume/") && !judgeRunnerConfigEdit(a, ctx, p)?.pass && !askedTestPaths(ctx).includes(p));
+  const outside = touched.inside.filter((p) => !matchesAny(p, allow) && !p.startsWith(".replume/") && !judgeRunnerConfigEdit(a, ctx, p)?.pass && !askedTestPaths(ctx).includes(p) && !askedToDelete(ctx, p));
   if (!outside.length) return null;
   const ignored = ignoredByGit(ctx.repoRoot, outside);
   const redirected = a.kind === "command" && a.command ? splitPaths(ctx.repoRoot, redirectTargets(a.command)).inside : [];
@@ -3644,7 +4087,7 @@ var outOfScopeEdit = (a, ctx) => {
 };
 var CAPTURED_OUTPUT = /\.(?:log|out|txt|json|xml)$/i;
 function symlinkPointsOutside(repoRoot2, rel3) {
-  const abs = resolve2(repoRoot2, rel3);
+  const abs = resolve3(repoRoot2, rel3);
   try {
     if (!lstatSync3(abs).isSymbolicLink()) return false;
   } catch {
@@ -3656,7 +4099,7 @@ function symlinkPointsOutside(repoRoot2, rel3) {
   } catch {
     return true;
   }
-  let root = resolve2(repoRoot2);
+  let root = resolve3(repoRoot2);
   try {
     root = realpathSync(repoRoot2);
   } catch {
@@ -3718,7 +4161,7 @@ function importedSources(repoRoot2, testPath) {
   }
   const out = [];
   const exts = ["", ".js", ".ts", ".mjs", ".cjs", ".jsx", ".tsx", ".py", "/index.js", "/index.ts", "/__init__.py"];
-  const root = resolve2(repoRoot2);
+  const root = resolve3(repoRoot2);
   for (const base4 of [...[...specs].map((spec) => join12(dirname7(testPath), spec)), ...rooted]) {
     const found = exts.map((e) => `${base4}${e}`).find((c) => {
       try {
@@ -3728,10 +4171,10 @@ function importedSources(repoRoot2, testPath) {
       }
     });
     if (!found) continue;
-    const rel3 = relative2(root, resolve2(root, found));
+    const rel3 = relative2(root, resolve3(root, found));
     if (!rel3 || rel3.startsWith("..") || isAbsolute2(rel3)) continue;
     try {
-      const real3 = relative2(realpathSync(root), realpathSync(resolve2(root, found)));
+      const real3 = relative2(realpathSync(root), realpathSync(resolve3(root, found)));
       if (real3.startsWith("..") || isAbsolute2(real3)) continue;
     } catch {
       continue;
@@ -3795,6 +4238,22 @@ function askedTestPaths(ctx) {
   if (!askedMemo.has(ctx)) askedMemo.set(ctx, askedTestsNow(ctx.repoRoot, ctx.contract));
   return askedMemo.get(ctx);
 }
+function judgeAskedAfterRun(repoRoot2, contract, path) {
+  let now = null;
+  try {
+    now = readFileSync10(join12(repoRoot2, path), "utf8");
+  } catch {
+    now = null;
+  }
+  const base4 = baseCommitOf(repoRoot2);
+  const start = base4 ? fileAt(repoRoot2, base4, path) : null;
+  if (now === null || start === null || now === start) return null;
+  const write = { kind: "write", tool: "Write", paths: [path], outsidePaths: [], command: null, changes: [{ path, before: start, after: now }], fingerprint: `after-run:${path}` };
+  const r = testWeakened(write, { contract, history: [], repoRoot: repoRoot2, mode: "auto" });
+  if (!r || r.action === "ok") return null;
+  const said = r.message.replace("this edit weakens tests", "the shell command that just ran weakened tests").replace("this edit was not made: ", "the shell command that just ran changed this: ").replace("this edit changes existing expectations", "the shell command that just ran changed existing expectations");
+  return prefixCode(codeForIntervention(r.rule, r.message), said);
+}
 function askedTestsNow(repoRoot2, contract) {
   const base4 = baseCommitOf(repoRoot2);
   const atStart = recordedAskedTests(repoRoot2, contract.id) ?? testEditsAskedFor(contract.task, repoRoot2, void 0, base4 ?? void 0).paths;
@@ -3835,14 +4294,6 @@ function expandGlobs(repoRoot2, paths) {
   }
   return [...paths.filter((p) => !globs.includes(p)), ...tracked2.filter((f) => matchesAny(f, globs))];
 }
-function movesInCommand(command) {
-  const out = [];
-  for (const seg of command.split(/&&|\|\||;/)) {
-    const m = /^\s*(?:git\s+mv|mv)\s+([\w@./-]+)\s+([\w@./-]+)\s*$/.exec(seg);
-    if (m) out.push([normalizeRel(m[1].replace(/^\.\//, "")), normalizeRel(m[2].replace(/^\.\//, ""))]);
-  }
-  return out;
-}
 function laterPromptAsks(ctx, path) {
   if (ctx.mode !== "auto") return false;
   const prompts = ctx.history.filter((e) => e.type === "prompt" && e.raw?.autoContract === void 0).map((e) => {
@@ -3900,15 +4351,11 @@ var protectedPathModified = (a, ctx) => {
     const operands = [...splitPaths(ctx.repoRoot, [a.command, ...innerScripts(a.command)].flatMap((c) => fileVerbOperands(c))).inside, ...expandGlobs(ctx.repoRoot, globOperands(a.command))].filter(guarded);
     const inline = ctx.mode === "auto" ? inlineWriteTargets(a.command, ctx.repoRoot).filter(guarded) : [];
     const moved = movedByCommand(a.command, askedTestPaths(ctx));
-    const byContent = [...heredocTestWrites(a, ctx), ...sedTestWrites(a, ctx)].map((w) => w.path);
-    const hit = [.../* @__PURE__ */ new Set([...redirected, ...operands, ...inline])].filter((p) => !moved.includes(p) && !byContent.includes(p));
+    const askedNow = askedTestPaths(ctx);
+    const hit = [.../* @__PURE__ */ new Set([...redirected, ...operands, ...inline])].filter((p) => !moved.includes(p) && !askedNow.includes(p));
     if (!hit.length) return null;
     const restored = honestRestores(a.command, ctx.repoRoot);
     if (hit.every((p) => restored.includes(p))) return null;
-    const asked = askedTestPaths(ctx);
-    if (asked.length && hit.every((p) => asked.includes(p))) {
-      return { rule: "protected_path_modified", action: "block", message: `${PREFIX} the task asks to change ${hit.join(", ")}, but a shell command that rewrites a test cannot be checked before it runs, so it was not run. Make the same change with your edit tool (Edit or Write): Replume checks an edit of this test by its content and lets it through unless it weakens the test (a skip, a removed test or assertion, a mock).` };
-    }
     return { rule: "protected_path_modified", action: "block", message: protectBlockMessage(ctx, hit, "command") };
   }
   return null;
@@ -4059,7 +4506,10 @@ var testWeakened = (a, ctx) => {
       afterLines.splice(i, 1);
       return false;
     });
-    const removedExisting = !!ch.before && removed > 0 && (start === void 0 || gone.some(existing));
+    const askedHere = askedTestPaths(ctx).includes(ch.path);
+    const keptAfter = askedHere && ch.before ? contentAfter(a, ctx, ch.path) : null;
+    const kept = !!keptAfter && sameInputsKept(start ?? ch.before, keptAfter.next, ch.path);
+    const removedExisting = !kept && !!ch.before && removed > 0 && (start === void 0 || gone.some(existing));
     if (removedExisting) {
       findings.push(`${ch.path}: ${removed} assertion${removed > 1 ? "s" : ""} removed`);
       severity = "block";
@@ -4069,7 +4519,7 @@ var testWeakened = (a, ctx) => {
       severity = "block";
     }
     const declsRemoved = count2(TEST_DECL, ch.before) - count2(TEST_DECL, ch.after);
-    if (ch.before && declsRemoved > 0 && askedTestPaths(ctx).includes(ch.path)) {
+    if (!kept && ch.before && declsRemoved > 0 && askedHere) {
       findings.push(`${ch.path}: ${declsRemoved} test${declsRemoved > 1 ? "s" : ""} removed`);
       severity = "block";
     }
@@ -4227,12 +4677,12 @@ function expandTmpdirVar(target, ctx) {
   if (!m) return target;
   const env = process.env.TMPDIR === void 0 ? tmpdir3() : process.env.TMPDIR;
   if (!env || !isAbsolute2(env)) return null;
-  const base4 = resolve2(env);
+  const base4 = resolve3(env);
   if (!isTempDir(ctx, base4)) return null;
   return base4 + target.slice(m[0].length);
 }
 function isTempDir(ctx, abs) {
-  const roots = ["/tmp", "/private/tmp", "/var/tmp", "/private/var/tmp", ...ctx.scratchDirs ?? []].map((d) => resolve2(d));
+  const roots = ["/tmp", "/private/tmp", "/var/tmp", "/private/var/tmp", ...ctx.scratchDirs ?? []].map((d) => resolve3(d));
   return roots.some((d) => abs === d || abs.startsWith(d + sep)) || /^\/(?:private\/)?var\/folders\/[^/]+\/[^/]+\/T(?:\/|$)/.test(abs);
 }
 function deletionLocation(target, ctx) {
@@ -4244,20 +4694,20 @@ function deletionLocation(target, ctx) {
     const segs = t.split("/");
     const gi = segs.findIndex((x) => /[*?[]/.test(x));
     const prefix = segs.slice(0, gi).join("/") || (t.startsWith("/") ? "/" : "");
-    if (!/[$`{]/.test(prefix) && prefix && isTempDir(ctx, resolve2(ctx.repoRoot, prefix))) return "outside";
+    if (!/[$`{]/.test(prefix) && prefix && isTempDir(ctx, resolve3(ctx.repoRoot, prefix))) return "outside";
     return "critical";
   }
   const expanded = t === "~" || t.startsWith("~/") ? homedir() + t.slice(1) : t;
-  const abs = resolve2(ctx.repoRoot, expanded);
-  const root = resolve2(ctx.repoRoot);
-  const home = resolve2(homedir());
+  const abs = resolve3(ctx.repoRoot, expanded);
+  const root = resolve3(ctx.repoRoot);
+  const home = resolve3(homedir());
   if (abs === home || abs === "/" || root !== abs && root.startsWith(abs + sep)) return "critical";
   const rel3 = relative2(root, abs);
   return !rel3 || !rel3.startsWith("..") && !isAbsolute2(rel3) ? "inside" : "outside";
 }
 function resolvedTarget(target, ctx) {
   const t = expandTmpdirVar(target.replace(/^["']|["']$/g, ""), ctx) ?? target;
-  return resolve2(ctx.repoRoot, t);
+  return resolve3(ctx.repoRoot, t);
 }
 function blockDeviceWrites(scripts) {
   const out = shellWriteTargets(scripts[0] ?? "").paths.filter(isBlockDevice);
@@ -4281,9 +4731,17 @@ function blockDeviceWrites(scripts) {
   }
   return [...new Set(out)];
 }
+function askedToDelete(ctx, path) {
+  if (!ctx.contract || ctx.mode !== "auto") return false;
+  return askedDeletionTargets(ctx.repoRoot, ctx.contract).includes(normalizeRel(path).replace(/\/+$/, ""));
+}
+function askedDeletionTargets(repoRoot2, contract) {
+  const asked = recordedAskedDeletions(repoRoot2, contract.id) ?? deletionsAskedFor(contract.task, repoRoot2, void 0, baseCommitOf(repoRoot2) ?? void 0);
+  return [...asked.dirs, ...asked.files];
+}
 function rmRfTargets(command) {
   const out = [];
-  for (const seg of command.split(/&&|\|\||;|\|/)) {
+  for (const seg of command.split(/&&|\|\||;|\||\n/)) {
     const words6 = seg.trim().split(/\s+/);
     const i = words6.findIndex((w) => w === "rm" || w.endsWith("/rm"));
     if (i < 0 || i > 0 && !["sudo", "command", "xargs"].includes(words6[i - 1])) continue;
@@ -4297,12 +4755,12 @@ function rmRfTargets(command) {
   return out;
 }
 function scratchRoots(ctx) {
-  return [tmpdir3(), "/tmp", "/private/tmp", ...ctx.scratchDirs ?? []].map((d) => resolve2(d));
+  return [tmpdir3(), "/tmp", "/private/tmp", ...ctx.scratchDirs ?? []].map((d) => resolve3(d));
 }
 function inScratch(ctx, abs) {
   const roots = scratchRoots(ctx).filter((d) => abs === d || abs.startsWith(d + sep));
   if (!roots.length) return false;
-  const home = resolve2(homedir());
+  const home = resolve3(homedir());
   if ((abs === home || abs.startsWith(home + sep)) && roots.every((d) => d.length <= home.length)) return false;
   return true;
 }
@@ -4359,7 +4817,7 @@ var destructiveCommand = (a, ctx) => {
       if (/^(\/|~|\$HOME|\*|\.{1,2}\/?)$/.test(clean3) || clean3.startsWith("~") || deletionLocation(clean3, ctx) === "critical") return true;
       const { inside, outside } = splitPaths(ctx.repoRoot, [expandTmpdirVar(clean3, ctx) ?? clean3]);
       if (outside.length) return !inScratch(ctx, outside[0]);
-      return !REGENERABLE.test(inside[0]);
+      return !REGENERABLE.test(inside[0]) && !askedToDelete(ctx, inside[0]);
     });
     if (bad.length) {
       return {
@@ -4478,112 +4936,60 @@ var RULES = {
   commit_without_tests: commitWithoutTests
 };
 var RANK = { ok: 0, warn: 1, block: 2 };
-function sedTestWrites(a, ctx) {
-  if (ctx.mode !== "auto" || a.kind !== "command" || !a.command || !/\b(?:sed|perl)\b/.test(a.command) || /[`$*?]|<</.test(a.command.replace(/'[^']*'/g, "''"))) return [];
-  const asked = askedTestPaths(ctx);
-  if (!asked.length) return [];
-  const segments2 = commandSegments(a.command);
-  const other = new Set(splitPaths(ctx.repoRoot, segments2.filter((s) => s.words[0] !== "sed" && s.words[0] !== "perl").flatMap((s) => fileVerbOperands(s.text))).inside);
-  const out = /* @__PURE__ */ new Map();
-  for (const seg of segments2.filter((s) => s.words[0] === "perl")) {
-    const scripts = [];
-    const files = [];
-    let inPlace = false;
-    let printing = false;
-    const words6 = seg.words.slice(1);
-    for (let i = 0; i < words6.length; i++) {
-      const w = words6[i];
-      if (/^-[pi]+$/.test(w)) {
-        inPlace ||= w.includes("i");
-        printing ||= w.includes("p");
-      } else if (/^-[pi]*e$/.test(w)) {
-        inPlace ||= w.includes("i");
-        printing ||= w.includes("p");
-        scripts.push(words6[++i] ?? "");
-      } else if (w.startsWith("-")) {
-        files.length = 0;
-        inPlace = false;
-        break;
-      } else files.push(w);
-    }
-    if (!inPlace || !printing || !scripts.length || !scripts.every((s) => SED_SUBSTITUTION.test(s) && !/[$@`{}]|\(\?/.test(s))) continue;
-    for (const p of splitPaths(ctx.repoRoot, files).inside.filter((f) => asked.includes(f) && !other.has(f))) {
-      try {
-        const current = out.get(p) ?? readFileSync10(join12(ctx.repoRoot, p), "utf8");
-        out.set(p, execFileSync7("perl", ["-pe", scripts.join(";")], { input: current, encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], timeout: 2e3 }));
-      } catch {
-        out.delete(p);
-      }
-    }
-  }
-  for (const seg of segments2.filter((s) => s.words[0] === "sed")) {
-    const scripts = [];
-    const flags = [];
-    const files = [];
-    let inPlace = false;
-    const words6 = seg.words.slice(1);
-    for (let i = 0; i < words6.length; i++) {
-      const w = words6[i];
-      if (w === "-i") {
-        inPlace = true;
-        if (words6[i + 1] === "") i++;
-      } else if (w === "-e") scripts.push(words6[++i] ?? "");
-      else if (w === "-E" || w === "-r") flags.push(w);
-      else if (w.startsWith("-")) {
-        files.length = 0;
-        inPlace = false;
-        break;
-      } else if (!scripts.length && !files.length && SED_SUBSTITUTION.test(w)) scripts.push(w);
-      else files.push(w);
-    }
-    if (!inPlace || !scripts.length || !scripts.every((s) => SED_SUBSTITUTION.test(s))) continue;
-    for (const p of splitPaths(ctx.repoRoot, files).inside.filter((f) => asked.includes(f) && !other.has(f))) {
-      try {
-        const current = out.get(p) ?? readFileSync10(join12(ctx.repoRoot, p), "utf8");
-        out.set(p, execFileSync7("sed", [...flags, ...scripts.flatMap((s) => ["-e", s])], { input: current, encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], timeout: 2e3 }));
-      } catch {
-        out.delete(p);
-      }
-    }
-  }
-  return [...out].map(([path, content]) => ({ path, content }));
-}
-var SED_SUBSTITUTION = /^s([^\w\s\\])(?:(?!\1)[^\n])*\1(?:(?!\1)[^\n])*\1[gI]*$/;
-function heredocTestWrites(a, ctx) {
-  if (ctx.mode !== "auto" || a.kind !== "command" || !a.command || !a.command.includes("<<")) return [];
-  const asked = askedTestPaths(ctx);
-  if (!asked.length) return [];
-  const writes = heredocFileWrites(a.command, ctx.repoRoot).filter((w) => asked.includes(w.path));
-  if (!writes.length) return [];
-  const other = /* @__PURE__ */ new Set([
-    ...splitPaths(ctx.repoRoot, [a.command, ...innerScripts(a.command)].flatMap((c) => fileVerbOperands(c))).inside,
-    ...inlineWriteTargets(a.command, ctx.repoRoot)
-  ]);
-  return writes.filter((w) => !other.has(w.path));
-}
 function evaluate(a, ctx) {
   const hits = [];
   for (const rule of Object.values(RULES)) {
     const r = rule(a, ctx);
     if (r && r.action !== "ok") hits.push(r);
   }
-  for (const w of [...heredocTestWrites(a, ctx), ...sedTestWrites(a, ctx)]) {
-    let current = "";
-    try {
-      current = readFileSync10(join12(ctx.repoRoot, w.path), "utf8");
-    } catch {
-      current = "";
-    }
-    const write = { kind: "write", tool: "Write", paths: [w.path], outsidePaths: [], command: null, changes: [{ path: w.path, before: current, after: w.content }], fingerprint: `${a.fingerprint}:${w.path}`, moves: movesInCommand(a.command ?? "") };
-    const r = testWeakened(write, ctx);
-    if (r && r.action !== "ok") hits.push(r);
-  }
   hits.sort((x, y) => RANK[y.action] - RANK[x.action]);
   for (const hit of hits) hit.message = prefixCode(codeForIntervention(hit.rule, hit.message), hit.message);
   const action = hits[0]?.action ?? "ok";
   return { action, hits, message: hits.length ? hits.map((h) => h.message).join("\n") : null };
 }
 
+// src/core/spec-conflict.ts
+var NOT_THE_TASK = /\b(?:spec|specification|docs?|documents?|documentation|readme|requirements?|the task|your request|the prompt|the brief|rules?|what you asked|as written|[\w./-]+\.(?:md|rst|txt|adoc))\b/i;
+var A_TEST = /\b(?:tests?|suite|specs?|assertions?|expectations?|[\w./-]+\.(?:test|spec)\.[a-z]+|test_\w+|[\w./-]*tests?\/[\w./-]+)\b/i;
+var DISAGREE = /\b(?:contradict\w*|conflict\w*|disagree\w*|mismatch\w*|inconsisten\w*|at odds|(?:both )?can(?:no|')t (?:both )?(?:be true|hold)|cannot both|does(?:n't| not) match|do(?:n't| not) match)\b/i;
+var CONFLICT_WORD = "(?:contradict\\w*|conflict\\w*|disagree\\w*|mismatch\\w*|inconsisten\\w*|at odds|wrong|incorrect|outdated|mistaken|stale)";
+var GAP = "(?:(?!because\\b|but\\b|since\\b|so\\b|while\\b|though\\b|although\\b|however\\b|and\\b|which\\b|that\\b|as\\b)[\\w'\u2019./-]+\\s+){0,6}?";
+var NEGATED = new RegExp(`(?:\\b(?:no|not|without|never|none|nothing|neither|nor|nobody|any)\\b|\\w+n['\u2019]t\\b)\\s+${GAP}${CONFLICT_WORD}`, "gi");
+var withoutDenials = (s) => s.replace(NEGATED, " ");
+var NO_CHOICE = /(?:\b(?:no|not|nobody|no one|never|nothing)\b|\w+n['’]t\b).{0,30}\b(?:pick|choose|decide)\b/i;
+var JUST_DENIED = /(?:\b(?:not|never)|n['’]t)\s+(?:\w+\s+)?$/i;
+var TEST_OVER_TASK = /\b(?:treated|took|counted|kept)\b.{0,40}\btests?\b.{0,20}\bas the spec\b|\bfollowed the (?:protected )?tests?\b|\b(?:changed|edited|rewrote|reworded|updated)\b.{0,40}\b(?:docs?|spec|[\w./-]+\.md)\b.{0,60}\b(?:to match|because|so that)\b.{0,40}\btests?\b|\bspec\b.{0,40}\b(?:unimplemented|not implemented)\b/i;
+var IS_WRONG = /\b(?:is|are|looks?|seems?|must be|appears? to be)\s+(?:\w+\s+)?(?:wrong|incorrect|outdated|out of date|stale|mistaken)\b/i;
+var SOMEONE_DECIDES = /\b(?:pick|choose|decide)\b.{0,30}\bwhich\b|\bwhich (?:one )?(?:is right|is correct|should win)\b|\byour call\b|\b(?:choice|decision) is yours\b|\b(?:needs?|for) (?:a person|someone|a human|you)\b.{0,20}\bdecide\b|\bdecide between\b|\b(?:someone|a person|you) (?:has|have|must|needs?) to (?:pick|choose|decide)\b/i;
+var CLAIM = "(?:says?|said|states?|expects?|asserts?|requires?|wants?|insists?|makes?|gives?|needs?)";
+var CONTRAST = "(?:but|while|whereas|though|although|yet|however)";
+var AGAINST = new RegExp(`\\b${CLAIM}\\b.*\\b${CONTRAST}\\b.*\\b${CLAIM}\\b`, "i");
+var ONE_IS_WRONG = /\bone of (?:them|those|these|the two)\b.{0,30}\b(?:wrong|mistaken|incorrect|outdated)\b/i;
+var TEST_EXPECTS = /\b(?:expects?|asserts?|requires?|wants?)\b/i;
+var DOC_SAYS = /\b(?:says?|said|states?|specif\w+|requires?)\b/i;
+var CONTRACT_REMARK = /contract\.ya?ml|\.replume\/|\bcontract conflict\b|\b(?:the|task|replume(?:['’]s)?) contract\b(?!\s+tests?\b)|\bunder protect\b|\bprotect (?:list|globs?)\b/i;
+var sentences = (m) => m.split(/(?<=[.!?:])\s+|\n+/).map((s) => s.replace(/[*`]/g, "").trim()).filter(Boolean);
+function statedSpecTestConflict(message, opts = {}) {
+  const all = sentences(message).filter((s) => !CONTRACT_REMARK.test(s));
+  for (let i = 0; i < all.length; i++) {
+    const s = all[i];
+    const near = [s, all[i + 1] ?? "", all[i + 2] ?? ""].join(" ");
+    const said = withoutDenials(s);
+    if (DISAGREE.test(said) && !/\bif\b/i.test(s) && A_TEST.test(near) && NOT_THE_TASK.test(near)) return s;
+    const over = TEST_OVER_TASK.exec(s);
+    if (over && !JUST_DENIED.test(s.slice(0, over.index))) return s;
+    if (IS_WRONG.test(said) && !/\b(?:if|whether)\b/i.test(s) && (A_TEST.test(s) || NOT_THE_TASK.test(s))) return s;
+    if ((SOMEONE_DECIDES.test(s) || ONE_IS_WRONG.test(said)) && !NO_CHOICE.test(s) && !/\bif\b/i.test(s)) return s;
+    if (AGAINST.test(s) && A_TEST.test(s) && NOT_THE_TASK.test(s) && !/\bif\b/i.test(s)) return s;
+  }
+  if (opts.red) {
+    const test = all.findIndex((s) => A_TEST.test(s) && TEST_EXPECTS.test(s));
+    const doc = all.findIndex((s, i) => i !== test && NOT_THE_TASK.test(s) && DOC_SAYS.test(s) && !/\bif\b/i.test(s));
+    if (test >= 0 && doc >= 0) return all[test];
+  }
+  return null;
+}
+
 // src/supervisor/unattributed.ts
 import { execFileSync as execFileSync8 } from "child_process";
 import { createHash as createHash4 } from "crypto";
@@ -4713,7 +5119,7 @@ function unattributedChanges(repoRoot2, base4, contract, events) {
     const protectedBy = glob ? `protected by "${glob}"` : scriptDiff ? `the test command: ${scriptDiff}` : null;
     const restore = target?.kind === "json-keys" && !glob ? `put ${target.keys.join(", ")} in ${path} back as they were (Edit tool)` : before.has(path) ? `git checkout ${ref} -- ${path}` : `remove ${path}`;
     return { path, kind: "file", blob: now.get(path) ?? "deleted", protectedBy, restore };
-  }).map((f) => byContent.has(f.path) ? { ...f, seenByContent: true } : f).filter((f) => !f.seenByContent || f.protectedBy);
+  }).map((f) => byContent.has(f.path) ? { ...f, seenByContent: true } : f).filter((f) => !f.seenByContent || f.protectedBy || f.kind === "lockfile");
 }
 function committedSinceTask(repoRoot2) {
   const b = readBaseline(baselinePath(contractPath(repoRoot2)));
@@ -5058,7 +5464,7 @@ var spawnRunner = (command, cwd, timeoutSec) => {
 var AUTO_BASE_RUN_RULE = "auto_base_run";
 var PRE_EXISTING_TEXT = "already failing before the task \u2014 not caused by the agent";
 var TASK_TEST_RED = "task test still red";
-var WHOLE_SUITE = [
+var WHOLE_SUITE2 = [
   /\b(?:make|get|have|keep)\s+(?:the\s+|all\s+(?:the\s+)?)?(?:(?:npm|yarn|pnpm)\s+(?:run\s+)?test|tests?|test\s+suite|suite|ci|build)\s+(?:pass|passing|green)\b/i,
   /\b(?:npm|yarn|pnpm)\s+(?:run\s+)?test\s+(?:passes|pass|passing|succeeds|is\s+green|goes\s+green|should\s+pass|must\s+pass)\b/i,
   /\b(?:all\s+(?:the\s+)?)?tests?\s+(?:must|should|need\s+to|have\s+to|to)\s+pass\b/i,
@@ -5068,7 +5474,7 @@ var WHOLE_SUITE = [
   /\bmake\s+(?:it|them)\s+(?:pass|green)\s*(?:[.!]|$)/im,
   /\bfix\s+(?:the\s+|all\s+(?:the\s+)?)?(?:failing|broken|red)\s+tests?\b/i
 ];
-var requiresWholeSuite = (task) => WHOLE_SUITE.some((re) => re.test(task));
+var requiresWholeSuite = (task) => WHOLE_SUITE2.some((re) => re.test(task));
 function inCopy(repoRoot2, commit, fn, startedAt = Date.now()) {
   const tmp = mkdtempSync4(join16(tmpdir6(), "replume-base-"));
   const root = join16(tmp, "repo");
@@ -5401,7 +5807,7 @@ function hasCommit(repoRoot2) {
 import { existsSync as existsSync18, readFileSync as readFileSync20 } from "fs";
 import { execFileSync as execFileSync17 } from "child_process";
 import { lstat as lstat4, mkdir as mkdir2, symlink, writeFile as writeFile3 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join26, relative as relative6, resolve as resolve4, sep as sep4 } from "path";
+import { isAbsolute as isAbsolute4, join as join26, relative as relative6, resolve as resolve5, sep as sep4 } from "path";
 import { performance as performance4 } from "perf_hooks";
 
 // src/sandbox/scenarios.ts
@@ -5548,12 +5954,12 @@ function countMatches(re, s) {
   const g = re.global ? re : new RegExp(re.source, re.flags + "g");
   return (s.match(g) ?? []).length;
 }
-var LITERAL = /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b|"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|`[^`\n]*`|\b(?:true|false|True|False|None|nil|null|undefined)\b/g;
+var LITERAL2 = /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b|"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|`[^`\n]*`|\b(?:true|false|True|False|None|nil|null|undefined)\b/g;
 function literalsOf(line2) {
-  return line2.match(LITERAL) ?? [];
+  return line2.match(LITERAL2) ?? [];
 }
 function shapeOf(line2) {
-  return line2.replace(LITERAL, "\0").replace(/\s+/g, " ").trim();
+  return line2.replace(LITERAL2, "\0").replace(/\s+/g, " ").trim();
 }
 function unquote(lit) {
   const t = lit.trim();
@@ -5665,9 +6071,9 @@ function testBypass(oldText, newText, path, opts = {}) {
   const out = [];
   for (const rule of rules) {
     const before = /* @__PURE__ */ new Map();
-    for (const m of oldCode.matchAll(rule.re)) before.set(norm(m[0]), (before.get(norm(m[0])) ?? 0) + 1);
+    for (const m of oldCode.matchAll(rule.re)) before.set(norm2(m[0]), (before.get(norm2(m[0])) ?? 0) + 1);
     for (const m of newCode.matchAll(rule.re)) {
-      const key = norm(m[0]);
+      const key = norm2(m[0]);
       const left = before.get(key) ?? 0;
       if (left > 0) {
         before.set(key, left - 1);
@@ -5732,7 +6138,7 @@ function titleSource(path) {
   const lang = langOf(path);
   return (lang === "js" || lang === "python") && (isTestFile(path) || TOP_TEST.test(path)) && !/\.d\.ts$/i.test(path);
 }
-var norm = (s) => s.replace(/\s+/g, " ").trim();
+var norm2 = (s) => s.replace(/\s+/g, " ").trim();
 
 // src/supervisor/checks/test-output.ts
 var num2 = (s) => s === void 0 ? null : Number(s);
@@ -5955,19 +6361,6 @@ function testWeakening(oldText, newText, path, opts = {}) {
   const severity = findings.some((f) => f.severity === "block") ? "block" : findings.length ? "warn" : "ok";
   return { path, lang, fileKind, findings, severity, steer: findings.length ? steerMessage(path, findings, { mode, allow: opts.allow }) : null };
 }
-function assertAliases(text) {
-  const out = /* @__PURE__ */ new Set();
-  const mod = String.raw`['"](?:node:)?assert(?:/strict)?['"]`;
-  for (const m of text.matchAll(new RegExp(String.raw`\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*${mod}\s*\)(?:\.strict)?`, "g"))) out.add(m[1]);
-  for (const m of text.matchAll(new RegExp(String.raw`\bimport\s+(?:\*\s+as\s+)?([A-Za-z_$][\w$]*)\s*(?:,\s*\{[^}]*\}\s*)?from\s*${mod}`, "g"))) out.add(m[1]);
-  for (const m of text.matchAll(new RegExp(String.raw`(?:\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*require\s*\(\s*${mod}\s*\)|\bimport\s*\{([^}]*)\}\s*from\s*${mod})`, "g")))
-    for (const part of (m[1] ?? m[2] ?? "").split(",")) {
-      const name = part.split(/\s*(?::|\bas\b)\s*/).pop()?.trim();
-      if (name && /^[A-Za-z_$][\w$]*$/.test(name)) out.add(name);
-    }
-  out.delete("assert");
-  return [...out];
-}
 function rulesWithAliases(r, lang, ...texts) {
   if (lang !== "js") return r;
   const names3 = [...new Set(texts.flatMap(assertAliases))];
@@ -6055,7 +6448,7 @@ function firstNew(re, o, n3) {
 }
 var normalize = (l) => l.replace(/^\s*(?:\/\/|#)\s*/, "").replace(/\s+/g, "");
 var pick2 = (mode, approve, auto) => mode === "approve" ? approve : auto;
-var IDENT = /[A-Za-z_]\w*(?=\s*\()/g;
+var IDENT2 = /[A-Za-z_]\w*(?=\s*\()/g;
 var FRAMEWORK_CALL = /^(?:expect|assert\w*|it|test|describe|t|should|to[A-Z]\w*|not|Fatal|Fatalf|Error|Errorf|Fail|FailNow|Log|Logf|Equal\w*|NotEqual|True|False|Nil|NotNil|Contains|Len|Empty|NotEmpty|Greater\w*|Less\w*|Panics|NoError|InDelta|self|pytest|raises|approx|assert_eq|assert_ne|assert)$/;
 var renameKey = (l) => normalize(l).replace(/[A-Za-z_$][\w$]*(?=\s*\()/g, "f");
 function lostAssertions(oCode, nCode, r) {
@@ -6089,7 +6482,7 @@ function lostAssertions(oCode, nCode, r) {
     if (k && newFlat.includes(k)) continue;
     if (newAsserts.some((a) => renameKey(a) === renameKey(l))) continue;
     const lits = literalsOf(l).map(unquote);
-    const calls = (l.match(IDENT) ?? []).filter((f) => !FRAMEWORK_CALL.test(f));
+    const calls = (l.match(IDENT2) ?? []).filter((f) => !FRAMEWORK_CALL.test(f));
     const litsOf = (x) => new Set(literalsOf(x).map(unquote));
     const newAssertsOnSubject = newAsserts.filter((a) => calls.some((f) => new RegExp(`\\b${f}\\s*\\(`).test(a)));
     if (newAssertsOnSubject.some((a) => lits.every((x) => litsOf(a).has(x)))) continue;
@@ -6308,7 +6701,7 @@ function steerMessage(path, findings, opts = {}) {
 // src/core/dependency-dirs.ts
 import { execFileSync as execFileSync12 } from "child_process";
 import { appendFileSync as appendFileSync4, existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname10, join as join18, resolve as resolve3 } from "path";
+import { dirname as dirname10, join as join18, resolve as resolve4 } from "path";
 var DEPENDENCY_PATH = /(^|\/)(node_modules|\.venv|venv|__pypackages__|bower_components|\.pnpm-store|\.yarn\/(cache|unplugged)|vendor\/bundle|\.bundle)(\/|$)/;
 var isDependencyPath = (path) => DEPENDENCY_PATH.test(path.split("\\").join("/"));
 var MARK = "# Replume: dependency directories are not the agent's change";
@@ -6317,7 +6710,7 @@ var git4 = (root, args) => execFileSync12("git", args, { cwd: root, encoding: "u
 function ensureDependencyExcludes(repoRoot2) {
   try {
     if (!existsSync13(join18(repoRoot2, ".replume"))) return;
-    const file3 = resolve3(repoRoot2, git4(repoRoot2, ["rev-parse", "--git-path", "info/exclude"]));
+    const file3 = resolve4(repoRoot2, git4(repoRoot2, ["rev-parse", "--git-path", "info/exclude"]));
     const have = existsSync13(file3) ? readFileSync15(file3, "utf8") : "";
     const lines = new Set(have.split("\n").map((l) => l.trim()));
     const patterns = [...BASE_PATTERNS];
@@ -6420,10 +6813,10 @@ function jiraChecklist(task, scenarios, tests = []) {
   const marker = task.indexOf(MARKER);
   if (marker < 0) return [];
   const criteria = task.slice(marker + MARKER.length).split("\n").map((s) => /^- (.+)$/.exec(s)?.[1]).filter((s) => !!s);
-  const norm3 = (s) => s.trim().replace(/\s+/g, " ").toLowerCase();
+  const norm4 = (s) => s.trim().replace(/\s+/g, " ").toLowerCase();
   return criteria.map((text) => {
     if (text === "[No acceptance criteria found on this Jira issue]") return { text, status: "not checked", evidence: "Jira issue has no recognized acceptance criteria" };
-    const matching = scenarios.filter((s) => norm3(s.description) === norm3(text));
+    const matching = scenarios.filter((s) => norm4(s.description) === norm4(text));
     if (!matching.length || matching.some((s) => s.status === "not_run")) {
       const test = matching.length ? null : testCovering(text, tests);
       return test ? { text, status: "not checked", evidence: `LIKELY COVERED by ${test.path} ("${test.title}") (word match); the test failed before and passed after, but no matching scenario ran` } : { text, status: "not checked", evidence: "no matching scenario ran" };
@@ -6461,7 +6854,7 @@ import { tmpdir as tmpdir7 } from "os";
 import { join as join19 } from "path";
 import { performance as performance3 } from "perf_hooks";
 async function git5(cwd, args, timeoutMs, tooLong) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve18, reject) => {
     const child = spawn2("git", args, { cwd, env: { PATH: process.env.PATH ?? "/usr/bin:/bin" }, stdio: ["ignore", "pipe", "pipe"] });
     let out = "", err = "", late = false;
     const timer = timeoutMs === void 0 ? null : setTimeout(() => {
@@ -6478,7 +6871,7 @@ async function git5(cwd, args, timeoutMs, tooLong) {
     child.on("close", (code2) => {
       if (timer) clearTimeout(timer);
       if (late) return reject(new CopyLimitError(tooLong?.() ?? `git ${args.join(" ")} took too long`));
-      if (code2 === 0) resolve17(out.trim());
+      if (code2 === 0) resolve18(out.trim());
       else reject(new Error(`git ${args.join(" ")}: ${err.trim() || `exit ${code2}`}`));
     });
   });
@@ -6509,14 +6902,14 @@ async function withWorkingCopy(repo, commit, keep, fn) {
 }
 async function runCommand(command, cwd, home, timeoutSec) {
   const started = performance3.now();
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     const child = spawn2(command, { cwd, shell: true, detached: process.platform !== "win32", env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: home }, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "", stderr = "", timedOut2 = false, settled = false;
     const finish = (exitCode) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve17({ stdout, stderr, exitCode, durationMs: Math.round(performance3.now() - started), timedOut: timedOut2 });
+      resolve18({ stdout, stderr, exitCode, durationMs: Math.round(performance3.now() - started), timedOut: timedOut2 });
     };
     child.stdout.on("data", (v2) => {
       stdout += v2.toString();
@@ -6734,7 +7127,9 @@ async function tamperingFindings(repo, base4, commit, entries, opts) {
       const after = blobAt(repo, commit, e.path);
       const confirmed = after !== null && isConfirmed(opts.repoRoot, e.path, after);
       if (asked || confirmed) {
-        const w2 = weakening(await patch2(...e.status === "R" ? [e.oldPath, e.path] : [e.path]), await atBase(e.oldPath ?? e.path)).filter((x) => !/assertions? changed/.test(x));
+        const startText = await atBase(e.oldPath ?? e.path);
+        const kept = asked && after !== null && sameInputsKept(startText, after, e.path);
+        const w2 = weakening(await patch2(...e.status === "R" ? [e.oldPath, e.path] : [e.path]), startText).filter((x) => !/assertions? changed/.test(x) && !(kept && /assertions? removed|tests? removed/.test(x)));
         const start = !w2.length && !confirmed && after !== null && opts.baseFailing && e.status === "M" ? blobAt(repo, base4, e.path) : null;
         const bent = start !== null && after !== null && opts.baseFailing ? bentToCode({ repoRoot: opts.repoRoot, path: e.path, start, after, changed: (p) => entries.some((x) => x.path === p || x.oldPath === p), baseFailing: opts.baseFailing }) : null;
         const moves = movesSince(opts.repoRoot, base4, commit);
@@ -7418,7 +7813,7 @@ function parseJudgeResponse(x) {
 function commandJudge(executable, apiKey) {
   return {
     name: `command:${executable}`,
-    judge: (req, signal) => new Promise((resolve17, reject) => {
+    judge: (req, signal) => new Promise((resolve18, reject) => {
       const env = { PATH: process.env.PATH, HOME: process.env.HOME };
       if (apiKey) env[ENV.apiKey] = apiKey;
       const child = spawn3(executable, [], { env, stdio: ["pipe", "pipe", "pipe"], signal });
@@ -7435,7 +7830,7 @@ function commandJudge(executable, apiKey) {
         if (code2 !== 0) return reject(new Error(`judge command exited ${code2}: ${err.trim().slice(0, 200)}`));
         if (stdinError) return reject(new Error(`judge command stdin failed: ${stdinError.message}`));
         try {
-          resolve17(parseJudgeResponse(JSON.parse(out)));
+          resolve18(parseJudgeResponse(JSON.parse(out)));
         } catch (e) {
           reject(e);
         }
@@ -8568,7 +8963,7 @@ async function isLink(p) {
   }
 }
 function safeRelative(root, path) {
-  const full = resolve4(root, path);
+  const full = resolve5(root, path);
   if (full !== root && !full.startsWith(root + "/")) throw new Error(`path outside repository: ${path}`);
   return full;
 }
@@ -8715,7 +9110,8 @@ function observedChanges(events, changedPaths, since) {
   }
   return {
     sessions: new Set(inTask.map((e) => e.sessionId)).size,
-    namedPaths: changedPaths.filter((p) => named.has(p) || byFailed.has(p)),
+    // (0.2.7) `rm -rf units` names the folder: the hooks saw the files in it go
+    namedPaths: changedPaths.filter((p) => named.has(p) || byFailed.has(p) || [...named].some((n3) => p.startsWith(`${n3}/`))),
     byFailedCommand: changedPaths.filter((p) => byFailed.has(p) && !named.has(p))
   };
 }
@@ -8734,7 +9130,7 @@ ${r.stderrTail}`)) return r;
   return { ...r, status: "unconfirmed", expectationFailures: ["a dependency this change adds is not installed in the verification copy (no network there, and this machine has no node_modules): the tests could not run; install the dependencies and run replume verify again"] };
 }
 async function runVerify(opts) {
-  const repo = resolve4(opts.repoPath);
+  const repo = resolve5(opts.repoPath);
   if (!isAbsolute4(opts.repoPath)) throw new Error("repoPath must be absolute");
   const startedAt = (/* @__PURE__ */ new Date()).toISOString(), started = performance4.now();
   const image = opts.dockerImage ?? DEFAULT_DOCKER_IMAGE;
@@ -9244,6 +9640,13 @@ function taskClosed(session) {
   const closedAt = session.map((e) => e.type === "rule_hit" && e.rule === AUTO_INCOMPLETE_RULE).lastIndexOf(true);
   return closedAt >= 0 && !session.slice(closedAt + 1).some(isWriteEvent);
 }
+function reportedConflict(session) {
+  for (const e of [...session].reverse()) {
+    const q = isGate(e, "block") ? e.raw?.conflictReported : null;
+    if (typeof q === "string") return q;
+  }
+  return null;
+}
 function gateBlocksSoFar(session) {
   return session.filter((e) => isGate(e, "block")).length;
 }
@@ -9330,12 +9733,15 @@ ${r0.stderr}`.replace(ANSI5, "");
       }
     }
     const what = run.status === "zero_tests" ? `ran zero tests (exit code 0)` : `failed (exit code ${run.exitCode ?? "unknown"})`;
-    if (so_far >= max) {
-      const reason = `the agent stopped with \`${command}\` ${what} after ${max} steer${max === 1 ? "" : "s"} (auto.max_retries ${max})`;
+    const conflictNow = run.status === "failed" ? statedSpecTestConflict(c.lastAssistantMessage, { red: true }) : null;
+    const conflictBefore = reportedConflict(c.session);
+    const conflictClosed = !!(conflictBefore || conflictNow) && so_far >= 1;
+    if (so_far >= max || conflictClosed) {
+      const reason = conflictClosed ? `the agent reported that the task and a test disagree, with \`${command}\` ${what}: no second retry` : `the agent stopped with \`${command}\` ${what} after ${max} steer${max === 1 ? "" : "s"} (auto.max_retries ${max})`;
       return {
         rule: AUTO_INCOMPLETE_RULE,
         outcome: "allow",
-        message: `Replume: \`${command}\` still ${what}. Replume is not blocking again (auto.max_retries ${max} reached); the report gives the result: ${run.summary || what}
+        message: `Replume: \`${command}\` still ${what}. Replume is not blocking again (${conflictClosed ? "the agent reported a conflict" : `auto.max_retries ${max} reached`}); the report gives the result: ${run.summary || what}
 Next, for the person: read the report. If the test is right, the code still needs fixing. If the test is wrong, correct it and run \`replume confirm-config ${testFileOfFailing(c.repoRoot, failingTestNames(`${r0.stdout}
 ${r0.stderr}`.replace(ANSI5, ""))) ?? "<test file>"}\`, then \`replume verify\`.`,
         summary: `${AUTO_INCOMPLETE_RULE}: ${reason}`,
@@ -9345,11 +9751,13 @@ ${r0.stderr}`.replace(ANSI5, ""))) ?? "<test file>"}\`, then \`replume verify\`.
       };
     }
     const snap = snapshotUnavailable(c.repoRoot);
-    const message = snap ? `Replume ran \`${command}\` before letting you stop: it ${what}. ${run.summary ? `${run.summary}
-` : ""}Replume could not check which failures existed before the task (the task-start snapshot failed${snap.files.length ? `; these files were already modified when the task started: ${snap.files.slice(0, 8).join(", ")}${snap.files.length > 8 ? ", \u2026" : ""}` : ""}), so it cannot tell whether this failure is yours. Fix only what you changed in this task; do not edit files you did not change. If the failure comes from files you did not change, say so in your final message. (auto steer ${so_far + 1} of ${max})` : `Replume ran \`${command}\` before letting you stop: it ${what}. ${run.summary ? `${run.summary}
-` : ""}${whyYours ? `Why this counts as yours: ${whyYours}. ` : ""}The agreed task is "${contract.task.slice(0, 200)}"; this failure belongs to it, whatever the last request said. If the task, or a document it names, and this test disagree, stop here and say so in your final message, naming the test: leave the test and the document as they are, and do not make the code match the test. Otherwise: Do not stop yet.${stopFixText(c.repoRoot, contract)} Run \`${command}\` yourself until it passes with at least one test. (auto steer ${so_far + 1} of ${max})`;
+    const conflictRule = `If the task, or a document it names, and this test disagree, stop here and say so in your final message, naming the test: leave the test and the document as they are, and do not make the code match the test.`;
+    const message = conflictNow ? `You reported that the task and a test disagree. That is the right stop: leave the test and the document as they are, and do not make the code match the test. A person decides which is right. Replume ran \`${command}\`: it ${what}. ${run.summary ? `${run.summary}
+` : ""}Finish anything else the task asks, then end with a final message that names the test. (auto steer 1 of 1)` : snap ? `${conflictRule} Replume ran \`${command}\` before letting you stop: it ${what}. ${run.summary ? `${run.summary}
+` : ""}Replume could not check which failures existed before the task (the task-start snapshot failed${snap.files.length ? `; these files were already modified when the task started: ${snap.files.slice(0, 8).join(", ")}${snap.files.length > 8 ? ", \u2026" : ""}` : ""}), so it cannot tell whether this failure is yours. Fix only what you changed in this task; do not edit files you did not change. If the failure comes from files you did not change, say so in your final message. (auto steer ${so_far + 1} of ${max})` : `${conflictRule} Otherwise: Replume ran \`${command}\` before letting you stop: it ${what}. ${run.summary ? `${run.summary}
+` : ""}${whyYours ? `Why this counts as yours: ${whyYours}. ` : ""}The agreed task is "${contract.task.slice(0, 200)}"; this failure belongs to it, whatever the last request said. Do not stop yet.${stopFixText(c.repoRoot, contract)} Run \`${command}\` yourself until it passes with at least one test. (auto steer ${so_far + 1} of ${max})`;
     return { failureOutput: `${r0.stdout}
-${r0.stderr}`.slice(-5e4), rule: AUTO_GATE_RULE, outcome: "block", message, summary: `${AUTO_GATE_RULE}: block on stop (\`${command}\` ${what}, steer ${so_far + 1} of ${max})`, raw: { ...raw6, outcome: "block", ...whyYours ? { whyYours } : {} }, ran };
+${r0.stderr}`.slice(-5e4), rule: AUTO_GATE_RULE, outcome: "block", message, summary: `${AUTO_GATE_RULE}: block on stop (\`${command}\` ${what}, steer ${so_far + 1} of ${conflictNow ? 1 : max})`, raw: { ...raw6, outcome: "block", ...whyYours ? { whyYours } : {}, ...conflictNow ? { conflictReported: conflictNow, maxRetries: 1 } : {} }, ran };
   };
 }
 
@@ -9440,7 +9848,7 @@ function passedTests(output) {
   }
   return out;
 }
-var norm2 = (s) => s.replace(/\s+/g, " ").trim();
+var norm3 = (s) => s.replace(/\s+/g, " ").trim();
 function changedLinesByFile(diff) {
   const out = /* @__PURE__ */ new Map();
   let file3 = "";
@@ -9469,12 +9877,12 @@ function changedLinesByFile(diff) {
   return out;
 }
 function quoteInDiff(diff, file3, quote4) {
-  const q = norm2(quote4);
+  const q = norm3(quote4);
   if (!/[A-Za-z0-9]{3}/.test(q)) return false;
   const lines = changedLinesByFile(diff);
   const pool = file3 && lines.has(file3) ? [file3] : [...lines.keys()];
-  const found = (x) => pool.some((f) => lines.get(f).some((l) => norm2(l).includes(x)));
-  return found(q) || /^[+-]/.test(q) && found(norm2(q.slice(1)));
+  const found = (x) => pool.some((f) => lines.get(f).some((l) => norm3(l).includes(x)));
+  return found(q) || /^[+-]/.test(q) && found(norm3(q.slice(1)));
 }
 var asList = (x) => Array.isArray(x) ? x.filter((y) => !!y && typeof y === "object" && !Array.isArray(y)) : [];
 var str = (x, n3 = 300) => typeof x === "string" ? redact(x).slice(0, n3) : "";
@@ -10486,6 +10894,8 @@ function classify4(i) {
   if (i.run?.status === "timeout") return { failure_class: "timeout", reason: "the test command did not finish in time", failing_tests: [], recovery: { text: "raise auto.test_timeout_sec in .replume/config, or make the tests faster", command: null } };
   if (i.run?.expectationFailures.some((f) => f.startsWith("zero_tests_ran"))) return { failure_class: "zero_tests", reason: "the test command ran zero tests", failing_tests: [], recovery: { text: "make the test command run at least one test", command: i.testCommand } };
   if (i.specConflict && i.status === "INCOMPLETE") return { failure_class: "spec_test_conflict", reason: i.specConflict, failing_tests: failing, recovery: { text: "a person decides whether the task or the test is right", command: /`(replume confirm-config [^`]+)`/.exec(i.specConflict)?.[1] ?? null } };
+  if (i.expectationConfirm && i.status === "INCOMPLETE") return { failure_class: "incomplete", reason: i.incompleteWhy ?? "an expected value changed in an asked test", failing_tests: failing, recovery: { text: "a person decides: if the new value is right, confirm it, then run replume verify", command: i.expectationConfirm } };
+  if (i.askedLeft?.length && i.status === "INCOMPLETE") return { failure_class: "incomplete", reason: i.incompleteWhy ?? "what the task asks to delete is still there", failing_tests: failing, recovery: { text: `delete ${i.askedLeft.slice(0, 5).join(", ")}${i.askedLeft.length > 5 ? ` and ${i.askedLeft.length - 5} more` : ""}, then run replume verify`, command: "replume verify" } };
   if (i.status === "FAIL" && (i.run?.status === "failed" || i.failedIds.length)) {
     const why = i.run?.taskTestRed?.length ? `task test still red: ${i.run.taskTestRed.slice(0, 3).join(", ")}` : `failed: ${i.failedIds.slice(0, 3).join(", ") || "test_command"}`;
     return { failure_class: "test_failed", reason: why, failing_tests: failing, recovery: i.testCommand ? { text: `fix the code until \`${i.testCommand}\` passes, then run replume verify`, command: i.testCommand } : verify };
@@ -10919,15 +11329,17 @@ function timeAndTokensLines(repoRoot2, sessionId2, agent, events, opts = {}) {
 // src/core/stats.ts
 var STATS_ROWS = {
   protected_test_edits_blocked: "Protected-test edits blocked",
+  asked_edits_redirected: "Asked edits redirected",
   bent_tests_caught: "Tests bent to the code caught",
   weakened_tests_blocked: "Weakened tests or test scripts blocked",
   protected_config_edits_blocked: "Protected config edits blocked",
   done_with_red_tests_caught: '"Done" with red tests caught',
   commit_gate_stops: "Commit-gate stops",
+  caught_at_verify: "Weakened or bent tests caught at verify",
   tests_rerun: "Test runs by Replume",
   other_interventions: "Other interventions"
 };
-var CATCHES = ["protected_test_edits_blocked", "bent_tests_caught", "weakened_tests_blocked", "protected_config_edits_blocked", "done_with_red_tests_caught", "commit_gate_stops"];
+var CATCHES = ["protected_test_edits_blocked", "bent_tests_caught", "weakened_tests_blocked", "protected_config_edits_blocked", "done_with_red_tests_caught", "commit_gate_stops", "caught_at_verify"];
 var REPLUME_RUNS = /* @__PURE__ */ new Set(["auto_stop_gate", "auto_incomplete", "auto_base_run", "auto_bent_run"]);
 var WEAKENED = /* @__PURE__ */ new Set([ERROR_CODES.TEST_WEAKENED, ERROR_CODES.TEST_BYPASS, ERROR_CODES.TEST_SCRIPT_CHANGED]);
 var AGENT_STEPS2 = /* @__PURE__ */ new Set(["tool_pre", "tool_post", "file_edit", "command"]);
@@ -10943,12 +11355,24 @@ function rowFor(e) {
   if (e.rule === "auto_stop_gate") return raw3(e).outcome === "block" ? { row: "done_with_red_tests_caught", code: code2 } : null;
   const blocked = e.action === "block";
   if (code2 === ERROR_CODES.TEST_BENT && blocked) return { row: "bent_tests_caught", code: code2 };
+  if (code2 === ERROR_CODES.PROTECTED_TEST_EDIT && blocked && (e.message ?? "").includes(ASKED_SHELL_REWRITE)) return { row: "asked_edits_redirected", code: code2 };
   if (code2 === ERROR_CODES.PROTECTED_TEST_EDIT && blocked) return { row: "protected_test_edits_blocked", code: code2 };
   if (code2 === ERROR_CODES.PROTECTED_CONFIG_EDIT && blocked) return { row: "protected_config_edits_blocked", code: code2 };
   if (WEAKENED.has(code2) && blocked) return { row: "weakened_tests_blocked", code: code2 };
   if (code2 === ERROR_CODES.COMMIT_BEFORE_GREEN && blocked) return { row: "commit_gate_stops", code: code2 };
   return { row: "other_interventions", code: code2 };
 }
+function blockMattered(e, verdict, bent, confirmedPaths) {
+  if (e.paths.some((p) => confirmedPaths.has(p) || bent.has(p))) return true;
+  if (!verdict || raw3(verdict).status === "PASS") return false;
+  const text = String(verdict.raw?.visibleSummary ?? verdict.summary ?? "");
+  return e.paths.some((p) => text.includes(p));
+}
+function caughtAtVerify(verdict) {
+  if (!verdict || raw3(verdict).status !== "FAIL") return null;
+  const code2 = /\[([A-Z][A-Z0-9_]+)\]/.exec(String(verdict.raw?.visibleSummary ?? ""))?.[1];
+  return code2 && (code2 === ERROR_CODES.TEST_BENT || WEAKENED.has(code2)) ? code2 : null;
+}
 function ranTests(e) {
   if (e.type !== "rule_hit" || !e.rule || !REPLUME_RUNS.has(e.rule)) return false;
   return e.rule !== "auto_stop_gate" || raw3(e).outcome === "block" || raw3(e).outcome === "passed";
@@ -10982,6 +11406,7 @@ function computeStats(repoRoot2, opts = {}) {
   const total = emptyAgent();
   const byAgent = /* @__PURE__ */ Object.create(null);
   const saved = { tokens: 0, ms: 0, episodes: 0, skippedSessions: 0, notCounted: 0, withTokens: 0, withTime: 0 };
+  const confirmedPaths = new Set(readConfirmations(repoRoot2).map((c) => c.path));
   for (const [sessionId2, list5] of bySession) {
     if (!list5.some((e) => STEP_TYPES.has(e.type))) continue;
     const agent = list5[0].agent;
@@ -10997,7 +11422,7 @@ function computeStats(repoRoot2, opts = {}) {
     const endedPass = !!verdict && raw3(verdict).status === "PASS";
     let lastStep = -1;
     list5.forEach((e, i) => {
-      if (AGENT_STEPS2.has(e.type)) lastStep = i;
+      if (AGENT_STEPS2.has(e.type) && e.raw?.treeSweep !== true) lastStep = i;
     });
     if (verdict && typeof raw3(verdict).status === "string") both((x) => {
       const s = raw3(verdict).status;
@@ -11013,8 +11438,9 @@ function computeStats(repoRoot2, opts = {}) {
         x.interventions.tests_rerun++;
       });
       if (e.type !== "rule_hit" && e.type !== "tool_pre" && e.type !== "stop" && e.type !== "command") continue;
-      const hit = rowFor(e);
-      if (!hit) continue;
+      const first = rowFor(e);
+      if (!first) continue;
+      const hit = first.row === "protected_test_edits_blocked" && !blockMattered(e, verdict, bent, confirmedPaths) ? { ...first, row: "asked_edits_redirected" } : first;
       if (hit.row === "done_with_red_tests_caught" && !(endedPass && i < lastStep)) continue;
       const call2 = typeof raw3(e).tool_use_id === "string" && raw3(e).tool_use_id ? String(raw3(e).tool_use_id) : `${e.rule}\0${e.message ?? e.summary}`;
       const key = `${hit.row}\0${hit.code}\0${call2}`;
@@ -11032,6 +11458,12 @@ function computeStats(repoRoot2, opts = {}) {
       }
       if (hit.row === "done_with_red_tests_caught" || hit.row === "bent_tests_caught" && e.paths.some((p) => bent.has(p))) confirmed.add(call2);
     }
+    if (caughtAtVerify(verdict) && ![...seen].some((k) => k.startsWith("weakened_tests_blocked\0") || k.startsWith("bent_tests_caught\0"))) {
+      both((x) => {
+        x.interventions.caught_at_verify++;
+      });
+      catches.add("verify");
+    }
     if (!catches.size) continue;
     both((x) => {
       x.catches += catches.size;
@@ -11228,7 +11660,7 @@ import { Command, Option } from "commander";
 // package.json
 var package_default = {
   name: "replume-cli",
-  version: "0.2.6",
+  version: "0.2.10",
   type: "module",
   bin: {
     replume: "dist/cli.js"
@@ -11280,7 +11712,7 @@ var package_default = {
 import { execFileSync as execFileSync37, spawn as spawn7 } from "child_process";
 import { existsSync as existsSync53, lstatSync as lstatSync8, mkdtempSync as mkdtempSync8, readdirSync as readdirSync15, readFileSync as readFileSync59, statSync as statSync15, unlinkSync } from "fs";
 import { homedir as homedir10, tmpdir as tmpdir15 } from "os";
-import { join as join69, resolve as resolve16 } from "path";
+import { join as join69, resolve as resolve17 } from "path";
 
 // src/hooks/session-start.ts
 import { execFileSync as execFileSync23 } from "child_process";
@@ -11288,12 +11720,12 @@ import { execFileSync as execFileSync23 } from "child_process";
 // src/session-state.ts
 import { execFileSync as execFileSync22 } from "child_process";
 import { existsSync as existsSync32, mkdirSync as mkdirSync18, readFileSync as readFileSync35, rmSync as rmSync11, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname15, join as join42, resolve as resolve5 } from "path";
+import { dirname as dirname15, join as join42, resolve as resolve6 } from "path";
 function sessionStatePath(repoDir, sessionId2) {
   const gitPath = execFileSync22("git", ["rev-parse", "--git-path", "replume"], {
     cwd: repoDir
   }).toString().trim();
-  const dir2 = resolve5(repoDir, gitPath);
+  const dir2 = resolve6(repoDir, gitPath);
   return join42(dir2, `${sessionId2}.start-sha`);
 }
 function writeStartSha(repoDir, sessionId2, sha2) {
@@ -11863,8 +12295,8 @@ async function runVerify2(opts) {
 }
 
 // src/supervisor/review-at-stop.ts
-import { readFileSync as readFileSync41 } from "fs";
-import { join as join49 } from "path";
+import { readFileSync as readFileSync42 } from "fs";
+import { join as join50 } from "path";
 
 // src/core/removed-tests.ts
 var TEST_FILE2 = /(^|\/)(tests?|__tests__|specs?)\/|[._-](test|spec)s?\.[cm]?[jt]sx?$|(^|\/)test_[^/]*\.py$|_test\.(py|go)$/i;
@@ -11923,19 +12355,225 @@ function removedTestLine(r) {
   return r.name ? `test removed: ${r.name} in ${r.file}` : `test file removed: ${r.file}${r.tests ? ` (${r.tests} test${r.tests === 1 ? "" : "s"})` : ""}`;
 }
 
-// src/core/confirm-edits.ts
+// src/core/shell-observe.ts
 import { execFileSync as execFileSync26 } from "child_process";
-var NOT_EDITS = /^(?:bash|shell|terminal|unknown)$|read|view|search|grep|glob|list|fetch|web/i;
-function confirmEdits(root, sid, agent) {
-  const ledger = ledgerPath(root);
-  const mine = readEvents(ledger).events.filter((e) => e.sessionId === sid);
-  const confirmed = new Set(mine.filter((e) => e.type === "file_edit" && e.raw?.ok !== false).flatMap((e) => e.paths));
-  const b = readBaseline(baselinePath(contractPath(root)));
-  const base4 = b.status === "ok" ? b.baseline.base_commit : null;
-  const git10 = (args) => execFileSync26("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-  const changed = (path) => {
-    try {
-      if (git10(["status", "--porcelain", "--", path]).trim()) return true;
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync35, lstatSync as lstatSync5, mkdirSync as mkdirSync21, readFileSync as readFileSync37, renameSync, rmSync as rmSync12, writeFileSync as writeFileSync21 } from "fs";
+import { tmpdir as tmpdir9 } from "os";
+import { join as join45, resolve as resolve7 } from "path";
+var MAX_TRACKED = 5e3;
+var SKIP2 = /^(\.claude|\.cursor|\.codex|\.git)\/|^\.replume\/(?!config$)/;
+function needsTreeCompare(a) {
+  if (a.kind !== "command" || !a.command) return false;
+  if (a.tool === "PowerShell") return true;
+  if (a.writeTargetNotParsed) return true;
+  const code2 = stripShellComments(a.command);
+  return INLINE_CODE.test(code2) || unobservable(code2);
+}
+var git8 = (cwd, args, input) => execFileSync26("git", ["--no-optional-locks", ...args], { cwd, encoding: "utf8", input, stdio: [input === void 0 ? "ignore" : "pipe", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 });
+function blobsOnDisk(top, paths) {
+  const out = /* @__PURE__ */ new Map();
+  const files = paths.filter((p) => {
+    try {
+      return lstatSync5(join45(top, p)).isFile();
+    } catch {
+      return false;
+    }
+  });
+  for (const p of paths) out.set(p, null);
+  if (!files.length) return out;
+  const ids = git8(top, ["hash-object", "--stdin-paths"], files.join("\n") + "\n").trim().split("\n");
+  files.forEach((p, i) => out.set(p, ids[i] ?? null));
+  return out;
+}
+function where(repoRoot2) {
+  const top = git8(repoRoot2, ["rev-parse", "--show-toplevel"]).trim();
+  const prefix = git8(repoRoot2, ["rev-parse", "--show-prefix"]).trim();
+  return { top, prefix };
+}
+function changedNow(repoRoot2) {
+  const { top, prefix } = where(repoRoot2);
+  let head = null;
+  try {
+    head = git8(top, ["rev-parse", "--verify", "-q", "HEAD"]).trim() || null;
+  } catch {
+    head = null;
+  }
+  const recs = git8(top, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--no-renames", "--", prefix ? prefix : "."]).split("\0").filter(Boolean);
+  if (recs.length > MAX_TRACKED) return null;
+  const paths = recs.map((r) => r.slice(3)).filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length)).filter((p) => !SKIP2.test(p));
+  return { top, prefix, head, paths };
+}
+function treeState(repoRoot2) {
+  try {
+    const now = changedNow(repoRoot2);
+    if (!now) return null;
+    const blobs = blobsOnDisk(now.top, now.paths.map((p) => now.prefix + p));
+    return { head: now.head, files: Object.fromEntries(now.paths.map((p) => [p, blobs.get(now.prefix + p) ?? null])) };
+  } catch {
+    return null;
+  }
+}
+function changedSince2(repoRoot2, before) {
+  try {
+    const now = changedNow(repoRoot2);
+    if (!now) return [];
+    const all = [.../* @__PURE__ */ new Set([...Object.keys(before.files), ...now.paths])].filter((p) => !SKIP2.test(p)).sort();
+    const after = blobsOnDisk(now.top, all.map((p) => now.prefix + p));
+    const unlisted = all.filter((p) => !(p in before.files));
+    const inHead = /* @__PURE__ */ new Map();
+    if (before.head && unlisted.length) {
+      const text = git8(now.top, ["ls-tree", "-z", before.head, "--", ...unlisted.map((p) => now.prefix + p)]);
+      for (const rec of text.split("\0").filter(Boolean)) {
+        const m = /^\d+ blob ([0-9a-f]+)\t(.+)$/.exec(rec);
+        if (m && m[2].startsWith(now.prefix)) inHead.set(m[2].slice(now.prefix.length), m[1]);
+      }
+    }
+    const out = [];
+    for (const p of all) {
+      const b = p in before.files ? before.files[p] : inHead.get(p) ?? null;
+      const a = after.get(now.prefix + p) ?? null;
+      if (a !== b) out.push({ path: p, before: b, after: a });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+var sha = (s, n3 = 16) => createHash6("sha1").update(s).digest("hex").slice(0, n3);
+var stateFile = (repoRoot2, sessionId2, toolUseId) => join45(tmpdir9(), "replume-tree", sha(resolve7(repoRoot2), 12), sha(sessionId2, 12), `${sha(toolUseId, 20)}.json`);
+function rememberTree(repoRoot2, sessionId2, toolUseId) {
+  if (!toolUseId) return false;
+  const state = treeState(repoRoot2);
+  if (!state) return false;
+  try {
+    const f = stateFile(repoRoot2, sessionId2, toolUseId);
+    mkdirSync21(join45(f, ".."), { recursive: true });
+    writeFileSync21(f, JSON.stringify(state));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function takeTreeChanges(repoRoot2, sessionId2, toolUseId) {
+  if (!toolUseId) return null;
+  const f = stateFile(repoRoot2, sessionId2, toolUseId);
+  let state;
+  try {
+    if (!existsSync35(f)) return null;
+    state = JSON.parse(readFileSync37(f, "utf-8"));
+  } catch {
+    return null;
+  } finally {
+    rmSync12(f, { force: true });
+  }
+  if (!state || typeof state.files !== "object" || state.files === null) return null;
+  return changedSince2(repoRoot2, state);
+}
+function forgetTree(repoRoot2, sessionId2, toolUseId) {
+  if (toolUseId) rmSync12(stateFile(repoRoot2, sessionId2, toolUseId), { force: true });
+}
+function changedFromBase(repoRoot2, base4) {
+  try {
+    const { top, prefix } = where(repoRoot2);
+    const list5 = (args) => git8(repoRoot2, args).split("\0").filter(Boolean);
+    let third = false;
+    try {
+      git8(repoRoot2, ["rev-parse", "--verify", "-q", `${base4}^3`]);
+      third = true;
+    } catch {
+      third = false;
+    }
+    const candidates = /* @__PURE__ */ new Set([
+      ...list5(["diff", "--name-only", "-z", "--no-renames", "--relative", base4]),
+      ...list5(["ls-files", "-o", "--exclude-standard", "-z"]),
+      ...third ? list5(["ls-tree", "-r", "-z", "--name-only", `${base4}^3`]) : []
+    ]);
+    const paths = [...candidates].filter((p) => !SKIP2.test(p));
+    if (paths.length > MAX_TRACKED) return null;
+    const inBase = /* @__PURE__ */ new Map();
+    const scope = paths.length && paths.length <= 500 ? ["--", ...paths] : [];
+    for (const ref of [...third ? [`${base4}^3`] : [], base4]) {
+      for (const rec of paths.length ? list5(["ls-tree", "-r", "-z", ref, ...scope]) : []) {
+        const m = /^\d+ blob ([0-9a-f]+)\t(.+)$/.exec(rec);
+        if (m) inBase.set(m[2], m[1]);
+      }
+    }
+    const now = blobsOnDisk(top, paths.map((p) => prefix + p));
+    const out = /* @__PURE__ */ new Map();
+    for (const p of paths) {
+      const before = inBase.get(p) ?? null;
+      const after = now.get(prefix + p) ?? null;
+      if (before !== after) out.set(p, { before, after });
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+var seenFile = (repoRoot2, base4) => join45(tmpdir9(), "replume-tree", sha(resolve7(repoRoot2), 12), `seen-${base4.slice(0, 16)}.json`);
+function newTreeChanges(repoRoot2, base4) {
+  if (!base4) return null;
+  const now = changedFromBase(repoRoot2, base4);
+  if (!now) return null;
+  const file3 = seenFile(repoRoot2, base4);
+  let seen = {};
+  try {
+    seen = JSON.parse(readFileSync37(file3, "utf-8"));
+  } catch {
+    seen = {};
+  }
+  const out = [];
+  for (const [path, c] of now) if (!(path in seen) || seen[path].after !== c.after) out.push({ path, before: path in seen ? seen[path].after : c.before, after: c.after });
+  for (const [path, c] of Object.entries(seen)) if (!now.has(path)) out.push({ path, before: c.after, after: c.before });
+  try {
+    mkdirSync21(join45(file3, ".."), { recursive: true });
+    const tmp = `${file3}.${process.pid}`;
+    writeFileSync21(tmp, JSON.stringify(Object.fromEntries(now)));
+    renameSync(tmp, file3);
+  } catch {
+  }
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+function writesFromTree(changes, namedInCommand) {
+  const named = namedInCommand.map((p) => p.replace(/\/+$/, ""));
+  const read4 = (c) => named.includes(c.path) || c.after === null && named.some((n3) => c.path.startsWith(`${n3}/`));
+  return { writes: changes.map((c) => c.path), hashWrites: changes.filter((c) => !read4(c)), treeCompared: true };
+}
+function landTreeChanges(repoRoot2, base4, event) {
+  const changes = newTreeChanges(repoRoot2, base4);
+  if (!changes?.length) return [];
+  const files = changes.map((c) => c.path);
+  appendEvent(ledgerPath(repoRoot2), {
+    agent: event.agent,
+    agentVersion: null,
+    sessionId: event.sessionId,
+    type: "command",
+    tool: null,
+    paths: files,
+    command: null,
+    summary: `changed outside a recorded step: ${files.join(", ")}`,
+    rule: null,
+    action: "ok",
+    message: null,
+    raw: { ok: true, treeSweep: true, ...writesFromTree(changes, []) }
+  });
+  return files;
+}
+
+// src/core/confirm-edits.ts
+import { execFileSync as execFileSync27 } from "child_process";
+var NOT_EDITS = /^(?:bash|shell|terminal|unknown)$|read|view|search|grep|glob|list|fetch|web/i;
+function confirmEdits(root, sid, agent) {
+  const ledger = ledgerPath(root);
+  const mine = readEvents(ledger).events.filter((e) => e.sessionId === sid);
+  const confirmed = new Set(mine.filter((e) => e.type === "file_edit" && e.raw?.ok !== false).flatMap((e) => e.paths));
+  const b = readBaseline(baselinePath(contractPath(root)));
+  const base4 = b.status === "ok" ? b.baseline.base_commit : null;
+  const git10 = (args) => execFileSync27("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  const changed = (path) => {
+    try {
+      if (git10(["status", "--porcelain", "--", path]).trim()) return true;
       if (base4) {
         try {
           git10(["diff", "--quiet", base4, "--", path]);
@@ -11964,16 +12602,16 @@ var confirmCopilotEdits = (root, sid) => confirmEdits(root, sid, "copilot");
 var confirmHermesEdits = (root, sid) => confirmEdits(root, sid, "hermes");
 
 // src/core/auto-report.ts
-import { execFileSync as execFileSync29 } from "child_process";
-import { existsSync as existsSync36, mkdirSync as mkdirSync24, mkdtempSync as mkdtempSync6, readFileSync as readFileSync40, rmSync as rmSync13, statSync as statSync8, writeFileSync as writeFileSync24 } from "fs";
-import { tmpdir as tmpdir10 } from "os";
-import { join as join48 } from "path";
+import { execFileSync as execFileSync30 } from "child_process";
+import { existsSync as existsSync37, mkdirSync as mkdirSync25, mkdtempSync as mkdtempSync6, readFileSync as readFileSync41, rmSync as rmSync14, statSync as statSync8, writeFileSync as writeFileSync25 } from "fs";
+import { tmpdir as tmpdir11 } from "os";
+import { join as join49 } from "path";
 
 // src/core/ignored-state.ts
-import { execFileSync as execFileSync27 } from "child_process";
-import { createHash as createHash6 } from "crypto";
-import { lstatSync as lstatSync5, mkdirSync as mkdirSync21, readdirSync as readdirSync10, readFileSync as readFileSync37, writeFileSync as writeFileSync21 } from "fs";
-import { join as join45 } from "path";
+import { execFileSync as execFileSync28 } from "child_process";
+import { createHash as createHash7 } from "crypto";
+import { lstatSync as lstatSync6, mkdirSync as mkdirSync22, readdirSync as readdirSync10, readFileSync as readFileSync38, writeFileSync as writeFileSync22 } from "fs";
+import { join as join46 } from "path";
 var FILE2 = "contracts/ignored-start.json";
 var MAX_FILES2 = 2e4;
 var HASH_FILE_BYTES = 16 * 1024 ** 2;
@@ -11983,7 +12621,7 @@ var COMPARE_MS = 15e3;
 var NOISE = /(^|\/)(__pycache__|\.pytest_cache|\.mypy_cache|\.ruff_cache|\.tox|\.nox|\.cache|\.turbo|\.parcel-cache|\.nyc_output|coverage)(\/|$)|\.(pyc|pyo|log|tsbuildinfo)$|(^|\/)(\.DS_Store|\.coverage)$/;
 function hashOf(path) {
   try {
-    return createHash6("sha256").update(readFileSync37(path)).digest("hex");
+    return createHash7("sha256").update(readFileSync38(path)).digest("hex");
   } catch {
     return null;
   }
@@ -11993,7 +12631,7 @@ function walk(repoRoot2, ms, hashAll) {
   const seen = { files: /* @__PURE__ */ Object.create(null), partial: false };
   let list5;
   try {
-    list5 = execFileSync27("git", ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 256 * 1024 ** 2, timeout: ms });
+    list5 = execFileSync28("git", ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 256 * 1024 ** 2, timeout: ms });
   } catch {
     seen.partial = true;
     return seen;
@@ -12006,12 +12644,12 @@ function walk(repoRoot2, ms, hashAll) {
       seen.partial = true;
       return;
     }
-    const st = lstatSync5(join45(repoRoot2, rel3), { throwIfNoEntry: false });
+    const st = lstatSync6(join46(repoRoot2, rel3), { throwIfNoEntry: false });
     if (!st) return;
     if (st.isDirectory()) {
       let names3 = [];
       try {
-        names3 = readdirSync10(join45(repoRoot2, rel3));
+        names3 = readdirSync10(join46(repoRoot2, rel3));
       } catch {
       }
       for (const name of names3) if (!skippedInCopy(name)) one(`${rel3}/${name}`);
@@ -12022,7 +12660,7 @@ function walk(repoRoot2, ms, hashAll) {
     count6++;
     const hashIt = st.isFile() && hashAll && st.size <= HASH_FILE_BYTES && hashed + st.size <= HASH_TOTAL_BYTES;
     if (hashIt) hashed += st.size;
-    seen.files[rel3] = [st.size, st.mtimeMs, hashIt ? hashOf(join45(repoRoot2, rel3)) : null];
+    seen.files[rel3] = [st.size, st.mtimeMs, hashIt ? hashOf(join46(repoRoot2, rel3)) : null];
   };
   for (const entry of list5.split("\0").filter(Boolean)) {
     const rel3 = entry.replace(/\/$/, "");
@@ -12037,15 +12675,15 @@ function ignoredWriter(path, events) {
   return "build (unattributed)";
 }
 function recordIgnoredState(repoRoot2, contractId, opts = {}) {
-  const dir2 = join45(repoRoot2, REPLUME_DIR, "contracts");
-  mkdirSync21(dir2, { recursive: true });
+  const dir2 = join46(repoRoot2, REPLUME_DIR, "contracts");
+  mkdirSync22(dir2, { recursive: true });
   const seen = walk(repoRoot2, opts.ms ?? RECORD_MS, true);
-  writeFileSync21(join45(repoRoot2, REPLUME_DIR, FILE2), JSON.stringify({ v: 1, contract_id: contractId, partial: seen.partial, files: seen.files }), { mode: 384 });
+  writeFileSync22(join46(repoRoot2, REPLUME_DIR, FILE2), JSON.stringify({ v: 1, contract_id: contractId, partial: seen.partial, files: seen.files }), { mode: 384 });
 }
 function ignoredChangesSinceStart(repoRoot2, contractId, opts = {}) {
   let start;
   try {
-    start = JSON.parse(readFileSync37(join45(repoRoot2, REPLUME_DIR, FILE2), "utf8"));
+    start = JSON.parse(readFileSync38(join46(repoRoot2, REPLUME_DIR, FILE2), "utf8"));
   } catch {
     return null;
   }
@@ -12060,7 +12698,7 @@ function ignoredChangesSinceStart(repoRoot2, contractId, opts = {}) {
       continue;
     }
     if (is[0] === was[0] && is[1] === was[1]) continue;
-    if (was[2] && is[0] === was[0] && hashOf(join45(repoRoot2, path)) === was[2]) continue;
+    if (was[2] && is[0] === was[0] && hashOf(join46(repoRoot2, path)) === was[2]) continue;
     changes.push({ path, kind: "modified" });
   }
   if (!start.partial) {
@@ -12069,40 +12707,6 @@ function ignoredChangesSinceStart(repoRoot2, contractId, opts = {}) {
   return { changes: changes.sort((a, b) => a.path < b.path ? -1 : 1), partial };
 }
 
-// src/core/spec-conflict.ts
-var NOT_THE_TASK = /\b(?:spec|specification|docs?|documents?|documentation|readme|requirements?|the task|your request|the prompt|the brief|rules?|what you asked|as written|[\w./-]+\.(?:md|rst|txt|adoc))\b/i;
-var A_TEST = /\b(?:tests?|suite|specs?|assertions?|expectations?|[\w./-]+\.(?:test|spec)\.[a-z]+|test_\w+|[\w./-]*tests?\/[\w./-]+)\b/i;
-var DISAGREE = /\b(?:contradict\w*|conflict\w*|disagree\w*|mismatch\w*|inconsisten\w*|at odds|(?:both )?can(?:no|')t (?:both )?(?:be true|hold)|cannot both|does(?:n't| not) match|do(?:n't| not) match)\b/i;
-var NEGATED = /\b(?:no|not|without|never|none|nothing|any|n't)\s+(?:\w+\s+){0,2}(?:contradict|conflict|disagree|mismatch|inconsisten|wrong)/i;
-var TEST_OVER_TASK = /\b(?:treated|took|counted|kept)\b.{0,40}\btests?\b.{0,20}\bas the spec\b|\bfollowed the (?:protected )?tests?\b|\b(?:changed|edited|rewrote|reworded|updated)\b.{0,40}\b(?:docs?|spec|[\w./-]+\.md)\b.{0,60}\b(?:to match|because|so that)\b.{0,40}\btests?\b|\bspec\b.{0,40}\b(?:unimplemented|not implemented)\b/i;
-var IS_WRONG = /\b(?:is|are|looks?|seems?|must be|appears? to be)\s+(?:\w+\s+)?(?:wrong|incorrect|outdated|out of date|stale|mistaken)\b/i;
-var SOMEONE_DECIDES = /\b(?:pick|choose|decide)\b.{0,30}\bwhich\b|\bwhich (?:one )?(?:is right|is correct|should win)\b|\byour call\b|\b(?:choice|decision) is yours\b|\b(?:needs?|for) (?:a person|someone|a human|you)\b.{0,20}\bdecide\b|\bdecide between\b|\b(?:someone|a person|you) (?:has|have|must|needs?) to (?:pick|choose|decide)\b/i;
-var CLAIM = "(?:says?|said|states?|expects?|asserts?|requires?|wants?|insists?|makes?|gives?|needs?)";
-var CONTRAST = "(?:but|while|whereas|though|although|yet|however)";
-var AGAINST = new RegExp(`\\b${CLAIM}\\b.*\\b${CONTRAST}\\b.*\\b${CLAIM}\\b`, "i");
-var ONE_IS_WRONG = /\bone of (?:them|those|these|the two)\b.{0,30}\b(?:wrong|mistaken|incorrect|outdated)\b/i;
-var TEST_EXPECTS = /\b(?:expects?|asserts?|requires?|wants?)\b/i;
-var DOC_SAYS = /\b(?:says?|said|states?|specif\w+|requires?)\b/i;
-var sentences = (m) => m.split(/(?<=[.!?:])\s+|\n+/).map((s) => s.replace(/[*`]/g, "").trim()).filter(Boolean);
-function statedSpecTestConflict(message, opts = {}) {
-  const all = sentences(message);
-  for (let i = 0; i < all.length; i++) {
-    const s = all[i];
-    const near = [s, all[i + 1] ?? "", all[i + 2] ?? ""].join(" ");
-    if (DISAGREE.test(s) && !NEGATED.test(s) && !/\bif\b/i.test(s) && A_TEST.test(near) && NOT_THE_TASK.test(near)) return s;
-    if (TEST_OVER_TASK.test(s)) return s;
-    if (IS_WRONG.test(s) && !NEGATED.test(s) && !/\b(?:if|whether)\b/i.test(s) && (A_TEST.test(s) || NOT_THE_TASK.test(s))) return s;
-    if ((SOMEONE_DECIDES.test(s) || ONE_IS_WRONG.test(s)) && !/\bif\b/i.test(s)) return s;
-    if (AGAINST.test(s) && A_TEST.test(s) && NOT_THE_TASK.test(s) && !/\bif\b/i.test(s)) return s;
-  }
-  if (opts.red) {
-    const test = all.findIndex((s) => A_TEST.test(s) && TEST_EXPECTS.test(s));
-    const doc = all.findIndex((s, i) => i !== test && NOT_THE_TASK.test(s) && DOC_SAYS.test(s) && !/\bif\b/i.test(s));
-    if (test >= 0 && doc >= 0) return all[test];
-  }
-  return null;
-}
-
 // src/report/session-report.ts
 function raw4(event) {
   return event.raw && typeof event.raw === "object" && !Array.isArray(event.raw) ? event.raw : {};
@@ -12344,6 +12948,7 @@ function renderSessionReport(ledgerEvents, extras = {}) {
     { title: "What was asked", lines: asked },
     { title: "Project memory", lines: memoryLines },
     { title: "What changed", lines: changed },
+    ...extras.askedTestChanges?.length ? [{ title: "Asked tests for a person to confirm", lines: extras.askedTestChanges }] : [],
     ...extras.ignoredChanged ? [{ title: IGNORED_CHANGED_TITLE, lines: ignoredChangedLines(extras.ignoredChanged) }] : [],
     { title: "Where Replume steered", lines: interventionLines(events, ledgerRuns) },
     { title: "Tests", lines: testLines },
@@ -12405,11 +13010,11 @@ ${reportTest.stderrTail}` : details.outputTail;
 
 // src/supervisor/judge-wire.ts
 import { spawn as spawn4 } from "child_process";
-import { execFileSync as execFileSync28 } from "child_process";
-import { createHash as createHash7 } from "crypto";
-import { mkdirSync as mkdirSync22, readFileSync as readFileSync38, writeFileSync as writeFileSync22 } from "fs";
-import { tmpdir as tmpdir9 } from "os";
-import { join as join46 } from "path";
+import { execFileSync as execFileSync29 } from "child_process";
+import { createHash as createHash8 } from "crypto";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync39, writeFileSync as writeFileSync23 } from "fs";
+import { tmpdir as tmpdir10 } from "os";
+import { join as join47 } from "path";
 
 // src/model-supervisor/index.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -12949,6 +13554,7 @@ function claimCheck(lastAgentMessage2, ledgerEvents, opts = {}) {
     if (c.kind !== "file_added" && c.kind !== "file_changed" || !c.file) continue;
     const hit = [...writes.written.keys()].some((p) => samePath(c.file, p));
     if (hit) continue;
+    if ((opts.changedFromBase ?? []).some((p) => samePath(c.file, p))) continue;
     const blocked = [...writes.blocked].some((p) => samePath(c.file, p));
     mismatches.push({
       kind: blocked ? "file_write_blocked" : "file_not_written",
@@ -13071,7 +13677,8 @@ function classify5(s, ctx) {
   if (writes.length) {
     if (s.type === "tool_pre") return neutral("write attempt; judged when it lands");
     if (allow.length) {
-      const out = writes.filter((p) => !matchesAny(normalizeRel(p), allow) && !RUNNER_CONFIG_FILE.test(normalizeRel(p)));
+      const asked = ctx.scope.askedDeletions ?? [];
+      const out = writes.filter((p) => !matchesAny(normalizeRel(p), allow) && !RUNNER_CONFIG_FILE.test(normalizeRel(p)) && !asked.includes(normalizeRel(p).replace(/\/+$/, "")));
       if (out.length) return { relation: "unrelated", why: `writes ${out.join(", ")} outside the task's allowed files`, outOfScope: out, label: label(s), weight: 2 };
       remember(writes, ctx);
       ctx.started = true;
@@ -13236,10 +13843,10 @@ function enqueueJudgeStep(config, job, deps = {}) {
   const cli = process.argv[1];
   if (!cli || !/(?:^|[\\/])(?:cli\.[cm]?[jt]s|replume(?:\.js)?)$/.test(cli)) return false;
   try {
-    const dir2 = join46(tmpdir9(), "replume-judge-jobs");
-    mkdirSync22(dir2, { recursive: true });
-    const file3 = join46(dir2, `${createHash7("sha1").update(`${job.sessionId}\0${job.forEventId}`).digest("hex").slice(0, 20)}.json`);
-    writeFileSync22(file3, JSON.stringify(job));
+    const dir2 = join47(tmpdir10(), "replume-judge-jobs");
+    mkdirSync23(dir2, { recursive: true });
+    const file3 = join47(dir2, `${createHash8("sha1").update(`${job.sessionId}\0${job.forEventId}`).digest("hex").slice(0, 20)}.json`);
+    writeFileSync23(file3, JSON.stringify(job));
     const child = spawn4(process.execPath, [...process.execArgv, cli, "hook", "judge-step", "--job", file3], { detached: true, stdio: "ignore", cwd: job.repoRoot });
     child.on("error", () => void 0);
     child.unref();
@@ -13318,7 +13925,7 @@ function pendingJudgeCandidate(events) {
 function fullDiff(repoRoot2, maxChars = 6e4) {
   const git10 = (args) => {
     try {
-      return execFileSync28("git", args, { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 8 * 1024 * 1024 });
+      return execFileSync29("git", args, { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 8 * 1024 * 1024 });
     } catch {
       return "";
     }
@@ -13326,7 +13933,7 @@ function fullDiff(repoRoot2, maxChars = 6e4) {
   let out = git10(["diff", "HEAD", "--", ".", ":(exclude).replume", ":(exclude).claude", ":(exclude).cursor", ":(exclude).codex"]);
   for (const f of git10(["ls-files", "--others", "--exclude-standard"]).split("\n").filter((f2) => f2 && !/^\.(?:replume|claude|cursor|codex)\//.test(f2)).slice(0, 20)) {
     try {
-      const text = readFileSync38(join46(repoRoot2, f), "utf8");
+      const text = readFileSync39(join47(repoRoot2, f), "utf8");
       out += `
 ${diffText("", text.slice(0, 2e4), f).replace("@@ -1,0 ", "@@ -0,0 ")}`;
     } catch {
@@ -13381,19 +13988,19 @@ function modelJudgeExtras(events, fresh) {
 }
 
 // src/core/project-memory.ts
-import { createHash as createHash8 } from "crypto";
-import { appendFileSync as appendFileSync7, existsSync as existsSync35, lstatSync as lstatSync6, mkdirSync as mkdirSync23, readFileSync as readFileSync39, readdirSync as readdirSync11, rmSync as rmSync12, writeFileSync as writeFileSync23 } from "fs";
-import { join as join47 } from "path";
-var dirOf = (root) => join47(root, ".replume", "memory");
+import { createHash as createHash9 } from "crypto";
+import { appendFileSync as appendFileSync7, existsSync as existsSync36, lstatSync as lstatSync7, mkdirSync as mkdirSync24, readFileSync as readFileSync40, readdirSync as readdirSync11, rmSync as rmSync13, writeFileSync as writeFileSync24 } from "fs";
+import { join as join48 } from "path";
+var dirOf = (root) => join48(root, ".replume", "memory");
 var clip2 = (value, max, root) => redactLedgerText(value.replace(/\s+/g, " ").trim(), root).slice(0, max);
 function ensureIgnored(root) {
-  const gi = join47(root, ".replume", ".gitignore");
-  mkdirSync23(join47(root, ".replume"), { recursive: true });
-  if (!existsSync35(gi)) {
-    writeFileSync23(gi, DEFAULT_REPLUME_GITIGNORE + "memory/\n");
+  const gi = join48(root, ".replume", ".gitignore");
+  mkdirSync24(join48(root, ".replume"), { recursive: true });
+  if (!existsSync36(gi)) {
+    writeFileSync24(gi, DEFAULT_REPLUME_GITIGNORE + "memory/\n");
     return;
   }
-  const current = readFileSync39(gi, "utf8");
+  const current = readFileSync40(gi, "utf8");
   if (!current.split(/\r?\n/).some((line2) => line2.trim() === "memory/"))
     appendFileSync7(gi, `${current.endsWith("\n") || !current ? "" : "\n"}memory/
 `);
@@ -13401,8 +14008,8 @@ function ensureIgnored(root) {
 function rememberSession(root, input) {
   ensureIgnored(root);
   const dir2 = dirOf(root);
-  mkdirSync23(dir2, { recursive: true });
-  const name = createHash8("sha256").update(input.sessionId).digest("hex").slice(0, 24) + ".json";
+  mkdirSync24(dir2, { recursive: true });
+  const name = createHash9("sha256").update(input.sessionId).digest("hex").slice(0, 24) + ".json";
   const entry = {
     v: 1,
     id: clip2(input.sessionId, 80, root),
@@ -13413,7 +14020,7 @@ function rememberSession(root, input) {
     verdict: clip2(input.verdict, 24, root)
   };
   try {
-    writeFileSync23(join47(dir2, name), JSON.stringify(entry) + "\n", { flag: "wx", mode: 384 });
+    writeFileSync24(join48(dir2, name), JSON.stringify(entry) + "\n", { flag: "wx", mode: 384 });
     return true;
   } catch (error) {
     if (error.code === "EEXIST") return false;
@@ -13434,21 +14041,21 @@ function rememberUnverifiedSession(root, sessionId2, task, events) {
 }
 function listProjectMemory(root) {
   const dir2 = dirOf(root);
-  if (!existsSync35(dir2)) return [];
+  if (!existsSync36(dir2)) return [];
   const out = [];
   const names3 = readdirSync11(dir2).filter((n3) => /^[a-f0-9]{24}\.json$/.test(n3)).map((name) => {
     try {
-      return { name, time: lstatSync6(join47(dir2, name)).mtimeMs };
+      return { name, time: lstatSync7(join48(dir2, name)).mtimeMs };
     } catch {
       return { name, time: 0 };
     }
   }).sort((a, b) => b.time - a.time).slice(0, 200);
   for (const { name } of names3) {
     try {
-      const path = join47(dir2, name);
-      const st = lstatSync6(path);
+      const path = join48(dir2, name);
+      const st = lstatSync7(path);
       if (!st.isFile() || st.size > 8192) continue;
-      const e = JSON.parse(readFileSync39(path, "utf8"));
+      const e = JSON.parse(readFileSync40(path, "utf8"));
       if (e.v === 1 && typeof e.id === "string" && typeof e.task === "string" && typeof e.at === "string" && Array.isArray(e.files) && e.files.every((f) => typeof f === "string") && Array.isArray(e.steers) && e.steers.every((s) => s && typeof s.kind === "string" && typeof s.reason === "string") && typeof e.verdict === "string")
         out.push({ v: 1, id: clip2(e.id, 80, root), at: e.at, task: clip2(e.task, 200, root), files: e.files.slice(0, 16).map((f) => clip2(f, 120, root)), steers: e.steers.slice(0, 4).map((s) => ({ kind: clip2(s.kind, 32, root), reason: clip2(s.reason, 150, root) })), verdict: clip2(e.verdict, 24, root) });
     } catch {
@@ -13458,12 +14065,12 @@ function listProjectMemory(root) {
 }
 function clearProjectMemory(root) {
   const dir2 = dirOf(root);
-  if (!existsSync35(dir2)) return 0;
+  if (!existsSync36(dir2)) return 0;
   let count6 = 0;
   for (const name of readdirSync11(dir2).filter((n3) => /^[a-f0-9]{24}\.json$/.test(n3))) {
-    const path = join47(dir2, name);
-    if (lstatSync6(path).isFile()) {
-      rmSync12(path);
+    const path = join48(dir2, name);
+    if (lstatSync7(path).isFile()) {
+      rmSync13(path);
       count6++;
     }
   }
@@ -13492,30 +14099,30 @@ function selectProjectMemory(root, task, files = []) {
 }
 
 // src/core/auto-report.ts
-var git8 = (cwd, args, env = process.env) => execFileSync29("git", args, { cwd, encoding: "utf8", env, stdio: ["ignore", "pipe", "pipe"] }).trim();
+var git9 = (cwd, args, env = process.env) => execFileSync30("git", args, { cwd, encoding: "utf8", env, stdio: ["ignore", "pipe", "pipe"] }).trim();
 function snapshotWorkingTree(repoRoot2, sessionId2) {
-  const head = git8(repoRoot2, ["rev-parse", "--verify", "HEAD^{commit}"]);
-  if (!git8(repoRoot2, ["status", "--porcelain"])) return { commit: head, snapshot: false, ref: null };
-  const dir2 = mkdtempSync6(join48(tmpdir10(), "replume-auto-"));
+  const head = git9(repoRoot2, ["rev-parse", "--verify", "HEAD^{commit}"]);
+  if (!git9(repoRoot2, ["status", "--porcelain"])) return { commit: head, snapshot: false, ref: null };
+  const dir2 = mkdtempSync6(join49(tmpdir11(), "replume-auto-"));
   try {
-    const env = { ...process.env, GIT_INDEX_FILE: join48(dir2, "index") };
-    git8(repoRoot2, ["read-tree", "HEAD"], env);
-    git8(repoRoot2, ["add", "-A"], env);
-    const tree = git8(repoRoot2, ["write-tree"], env);
+    const env = { ...process.env, GIT_INDEX_FILE: join49(dir2, "index") };
+    git9(repoRoot2, ["read-tree", "HEAD"], env);
+    git9(repoRoot2, ["add", "-A"], env);
+    const tree = git9(repoRoot2, ["write-tree"], env);
     const ident = (key) => {
       try {
-        return git8(repoRoot2, ["config", "--get", key]);
+        return git9(repoRoot2, ["config", "--get", key]);
       } catch {
         return "";
       }
     };
     const withIdent = { ...process.env, ...ident("user.name") ? {} : { GIT_AUTHOR_NAME: "Replume", GIT_COMMITTER_NAME: "Replume" }, ...ident("user.email") ? {} : { GIT_AUTHOR_EMAIL: "replume@localhost", GIT_COMMITTER_EMAIL: "replume@localhost" } };
-    const commit = git8(repoRoot2, ["commit-tree", tree, "-p", head, "-m", `Replume auto snapshot of the working tree (session ${sessionId2.slice(0, 8)})`], withIdent);
+    const commit = git9(repoRoot2, ["commit-tree", tree, "-p", head, "-m", `Replume auto snapshot of the working tree (session ${sessionId2.slice(0, 8)})`], withIdent);
     const ref = `refs/replume/auto/${sessionId2.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 40) || "session"}`;
-    git8(repoRoot2, ["update-ref", ref, commit]);
+    git9(repoRoot2, ["update-ref", ref, commit]);
     return { commit, snapshot: true, ref };
   } finally {
-    rmSync13(dir2, { recursive: true, force: true });
+    rmSync14(dir2, { recursive: true, force: true });
   }
 }
 function agentOfSession(repoRoot2, sessionId2) {
@@ -13543,16 +14150,65 @@ ${e.summary}`;
 var shortCommand = (c) => c.length > 240 ? `${c.slice(0, 237)}\u2026` : c;
 var blindLine = (s) => `${UNPARSED_OUTSIDE_LINE}: \`${shortCommand(s.command)}\` wrote to a path computed when it ran, and no file git tracks changed with it`;
 var seenLine = (s) => `\`${shortCommand(s.command)}\` wrote to a path computed when it ran; comparing the tree before and after it shows it changed ${s.files.join(", ")} in the repository (checked above). A write it made outside the repository was not seen`;
+function askedTestChanges(repoRoot2, base4, contract, changed, commit) {
+  const asked = askedTestsNow(repoRoot2, contract);
+  const moves = movesSince(repoRoot2, base4, commit);
+  const out = [];
+  for (const path of changed.filter((p) => asked.includes(p))) {
+    let now = null;
+    try {
+      now = readFileSync41(join49(repoRoot2, path), "utf8");
+    } catch {
+      now = null;
+    }
+    const from = moves.find(([, to]) => to === path)?.[0] ?? path;
+    const start = fileAt(repoRoot2, base4, from);
+    if (now === null || start === null || start === now || isConfirmed(repoRoot2, path, now)) continue;
+    const c = compareCases(start, now, path);
+    const left = c.changes.filter((x) => !taskNamesValue(contract.task, x.to));
+    if (c.kind === "same" || c.kind === "values" && !left.length) continue;
+    let diff = [];
+    if (c.kind === "other") {
+      try {
+        diff = execFileSync30("git", ["diff", "--no-color", "--unified=1", base4, "--", from, path], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 8 * 1024 * 1024 }).split("\n").filter((l) => l && !/^(?:diff --git|index )/.test(l)).slice(0, 60);
+      } catch {
+        diff = [];
+      }
+    }
+    out.push({ path, kind: c.kind, changes: left, confirm: confirmCommand(path, now), diff });
+  }
+  return out;
+}
+var TEST_DECL_LINE = /^\s*(?:async\s+)?def\s+test_\w*|\b(?:test|it)\s*\(/gm;
+function casesExplainDrop(repoRoot2, base4, contract, changed, drop, commit) {
+  const asked = askedTestsNow(repoRoot2, contract);
+  const moves = movesSince(repoRoot2, base4, commit);
+  const tests = changed.filter(isTestFile);
+  if (!tests.length || tests.some((p) => !asked.includes(p))) return false;
+  let fewer = 0;
+  for (const path of tests) {
+    let now = null;
+    try {
+      now = readFileSync41(join49(repoRoot2, path), "utf8");
+    } catch {
+      now = null;
+    }
+    const start = fileAt(repoRoot2, base4, moves.find(([, to]) => to === path)?.[0] ?? path);
+    if (now === null || start === null || compareCases(start, now, path).kind === "other") return false;
+    fewer += (start.match(TEST_DECL_LINE) ?? []).length - (now.match(TEST_DECL_LINE) ?? []).length;
+  }
+  return fewer >= drop;
+}
 function specConflictWhy(repoRoot2, quote4, message, failing) {
   let tests = [];
   try {
-    tests = execFileSync29("git", ["ls-files"], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 }).split("\n").filter((f) => f && isTestFile(f));
+    tests = execFileSync30("git", ["ls-files"], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 }).split("\n").filter((f) => f && isTestFile(f));
   } catch {
   }
   const titles = [...message.matchAll(/[`'"]([^`'"\n]{3,80})[`'"]/g)].map((m) => m[1]);
   const holdsTitle = (f) => {
     try {
-      const t = readFileSync40(join48(repoRoot2, f), "utf8");
+      const t = readFileSync41(join49(repoRoot2, f), "utf8");
       return titles.some((q) => t.includes(q));
     } catch {
       return false;
@@ -13563,11 +14219,11 @@ function specConflictWhy(repoRoot2, quote4, message, failing) {
 }
 function buildCommand(repoRoot2) {
   try {
-    if (JSON.parse(readFileSync40(join48(repoRoot2, "package.json"), "utf8"))?.scripts?.build) return "npm run build";
+    if (JSON.parse(readFileSync41(join49(repoRoot2, "package.json"), "utf8"))?.scripts?.build) return "npm run build";
   } catch {
   }
   try {
-    if (/^build\s*:/m.test(readFileSync40(join48(repoRoot2, "Makefile"), "utf8"))) return "make build";
+    if (/^build\s*:/m.test(readFileSync41(join49(repoRoot2, "Makefile"), "utf8"))) return "make build";
   } catch {
   }
   return null;
@@ -13582,7 +14238,7 @@ function rewrittenByBuild(repoRoot2, events, path) {
   const built = events.slice(lastWrite + 1).some((e) => e.type === "command" && e.raw?.ok !== false && !!e.command && BUILD_RUN.test(e.command));
   if (!built) return false;
   try {
-    return statSync8(join48(repoRoot2, path)).mtimeMs > Date.parse(events[lastWrite].ts);
+    return statSync8(join49(repoRoot2, path)).mtimeMs > Date.parse(events[lastWrite].ts);
   } catch {
     return false;
   }
@@ -13602,21 +14258,21 @@ function lastAgentMessage(events) {
 }
 function refreshReportTime(repoRoot2, sessionId2) {
   const stem2 = sessionId2.replace(/[^A-Za-z0-9_-]/g, "") || "session";
-  const mdPath = join48(repoRoot2, REPLUME_DIR, "reports", `${stem2}.md`);
-  const htmlPath = join48(repoRoot2, REPLUME_DIR, "reports", `${stem2}.html`);
-  if (!existsSync36(mdPath)) return false;
+  const mdPath = join49(repoRoot2, REPLUME_DIR, "reports", `${stem2}.md`);
+  const htmlPath = join49(repoRoot2, REPLUME_DIR, "reports", `${stem2}.html`);
+  if (!existsSync37(mdPath)) return false;
   try {
     const lines = timeAndTokensLines(repoRoot2, sessionId2, agentOfSession(repoRoot2, sessionId2), sessionEvents(repoRoot2, sessionId2));
     const esc = (t) => t.replace(/([\\`*_[])/g, "\\$1");
     const htmlEsc = (t) => t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-    const md2 = readFileSync40(mdPath, "utf8");
+    const md2 = readFileSync41(mdPath, "utf8");
     const mdNew = md2.replace(/(## Time and tokens\n\n)((?:- .*\n?)+)/, (_m, head) => `${head}${lines.map((l) => `- ${esc(l)}`).join("\n")}
 `);
-    if (mdNew !== md2) writeFileSync24(mdPath, mdNew);
-    if (existsSync36(htmlPath)) {
-      const html2 = readFileSync40(htmlPath, "utf8");
+    if (mdNew !== md2) writeFileSync25(mdPath, mdNew);
+    if (existsSync37(htmlPath)) {
+      const html2 = readFileSync41(htmlPath, "utf8");
       const htmlNew = html2.replace(/(<h2>Time and tokens<\/h2>\s*<ul>)([\s\S]*?)(<\/ul>)/, (_m, a, _b, c) => `${a}${lines.map((l) => `<li>${htmlEsc(l)}</li>`).join("")}${c}`);
-      if (htmlNew !== html2) writeFileSync24(htmlPath, htmlNew);
+      if (htmlNew !== html2) writeFileSync25(htmlPath, htmlNew);
     }
     return mdNew !== md2;
   } catch {
@@ -13640,7 +14296,7 @@ function stepsSection(events, repoRoot2) {
 }
 function assumptions(f) {
   const out = [];
-  out.push(`Mode: ${f.config.mode}${f.config.modeSource === "default" ? ` (the default; ${existsSync36(configPath(f.repoRoot)) ? `\`${REPLUME_DIR}/config\` has no valid mode` : `no \`${REPLUME_DIR}/config\``})` : ` (from \`${REPLUME_DIR}/config\`)`}.`);
+  out.push(`Mode: ${f.config.mode}${f.config.modeSource === "default" ? ` (the default; ${existsSync37(configPath(f.repoRoot)) ? `\`${REPLUME_DIR}/config\` has no valid mode` : `no \`${REPLUME_DIR}/config\``})` : ` (from \`${REPLUME_DIR}/config\`)`}.`);
   for (const p of f.config.problems) out.push(`Config problem: ${p}.`);
   const contract = (() => {
     try {
@@ -13676,7 +14332,7 @@ function assumptions(f) {
   const tree = (c) => {
     if (!c) return null;
     try {
-      return execFileSync29("git", ["rev-parse", `${c}^{tree}`], { cwd: f.repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      return execFileSync30("git", ["rev-parse", `${c}^{tree}`], { cwd: f.repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return null;
     }
@@ -13706,14 +14362,14 @@ function headline(status, report, steps, incomplete, extra) {
 }
 var revParse = (repoRoot2, ref) => {
   try {
-    return git8(repoRoot2, ["rev-parse", "--verify", `${ref}^{commit}`]);
+    return git9(repoRoot2, ["rev-parse", "--verify", `${ref}^{commit}`]);
   } catch {
     return null;
   }
 };
 function removedTestsBetween(repoRoot2, base4, commit) {
   try {
-    return removedTests(execFileSync29(
+    return removedTests(execFileSync30(
       "git",
       ["diff", "--no-color", "-U0", base4, commit, "--", ".", `:(exclude)${REPLUME_DIR}`],
       { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 }
@@ -13724,7 +14380,7 @@ function removedTestsBetween(repoRoot2, base4, commit) {
 }
 function numstat(repoRoot2, base4, commit) {
   try {
-    return git8(repoRoot2, ["diff", "--numstat", base4, commit]).split("\n").filter(Boolean).flatMap((line2) => {
+    return git9(repoRoot2, ["diff", "--numstat", base4, commit]).split("\n").filter(Boolean).flatMap((line2) => {
       const [a, r, ...rest] = line2.split("	");
       const path = rest.join("	");
       if (!path || path.startsWith(`${REPLUME_DIR}/`)) return [];
@@ -13780,6 +14436,10 @@ async function autoFinish(repoRoot2, sessionId2, opts = {}) {
   ensureDependencyExcludes(repoRoot2);
   confirmEdits(repoRoot2, sessionId2, "copilot");
   confirmEdits(repoRoot2, sessionId2, "hermes");
+  {
+    const agentOf = readEvents(ledgerPath(repoRoot2)).events.find((e) => e.sessionId === sessionId2)?.agent;
+    if (agentOf) landTreeChanges(repoRoot2, baseCommitOf(repoRoot2), { agent: agentOf, sessionId: sessionId2 });
+  }
   const config = loadConfig(repoRoot2);
   const events = sessionEvents(repoRoot2, sessionId2);
   const incompleteHit = [...events].reverse().find((e) => e.type === "rule_hit" && e.rule === AUTO_INCOMPLETE_RULE);
@@ -13846,6 +14506,7 @@ async function autoFinish(repoRoot2, sessionId2, opts = {}) {
     const now = run && !run.runnerMissing ? parseTestCounts(`${run.stdoutTail}
 ${run.stderrTail}`) : null;
     const after = now ? now.passed + now.failed + now.skipped : null;
+    if (typeof before === "number" && after !== null && after < before && contract && base4 && casesExplainDrop(repoRoot2, base4, contract, changesList.map((c) => c.path), before - after, snap?.commit)) return null;
     return typeof before === "number" && after !== null && after < before ? `fewer tests ran than at the task start (${before} \u2192 ${after}): a test may have been removed, skipped or deselected` : null;
   })();
   const ignoredWritten = (report && snap && !fail2 ? ignoredAmong(repoRoot2, events.flatMap((e) => e.type === "file_edit" && e.raw?.ok !== false ? e.paths : commandWrites(e))) : []).filter((p) => !rewrittenByBuild(repoRoot2, events, p));
@@ -13855,12 +14516,19 @@ ${run.stderrTail}`) : null;
   const cleanRed = report?.verdict === "fail" && !report.tampering.length && !report.extra.some((x) => !x.informational);
   const gateSawRed = events.some((e) => e.type === "rule_hit" && (e.rule === AUTO_INCOMPLETE_RULE || e.rule === "auto_stop_gate" && e.raw?.outcome === "block"));
   const failingNames = report?.scenarios.find((r) => r.id === "test_command")?.failingTests ?? [];
-  const stated = report?.verdict === "pass" ? statedSpecTestConflict(lastAgentMessage(events)) : cleanRed ? statedSpecTestConflict(lastAgentMessage(events), { red: gateSawRed }) : null;
+  const stated = report?.verdict === "pass" ? statedSpecTestConflict(lastAgentMessage(events)) : cleanRed ? statedSpecTestConflict(lastAgentMessage(events), { red: gateSawRed }) ?? reportedConflict(events) : null;
   const conflictWhy = stated ? specConflictWhy(repoRoot2, stated, lastAgentMessage(events), failingNames) : null;
   const inCommit = contract && snap?.snapshot ? committedProtected(repoRoot2, contract) : null;
   const restoredInCommit = inCommit ? inCommit.paths.filter((p) => !changesList.some((c) => c.path === p)) : [];
   const committedWhy = restoredInCommit.length ? `commit ${inCommit.commit} holds a change to protected ${restoredInCommit.join(", ")} that the working tree no longer has, and Replume checked the working tree, not that commit. Next: \`git revert ${inCommit.commit}\`` : null;
-  const incompleteWhy = (copyLimit ? problem : null) ?? committedWhy ?? (outsideReason ? null : conflictWhy) ?? (fail2 ? null : incomplete) ?? outsideReason ?? ignoredWhy ?? (scriptBlind && !fail2 ? blindLine(blindScripts[0]) : null) ?? (shrink && !fail2 ? shrink : null);
+  const askedDeletions = contract ? recordedAskedDeletions(repoRoot2, contract.id) ?? deletionsAskedFor(contract.task, repoRoot2, void 0, report?.baseCommit ?? void 0) : null;
+  const leftBehind = report && report.verdict !== "fail" && askedDeletions ? askedDeletions.files.filter((f) => existsSync37(join49(repoRoot2, f))) : [];
+  const leftWhy = leftBehind.length ? `the task asks to delete ${leftBehind.slice(0, 3).join(", ")}${leftBehind.length > 3 ? ` and ${leftBehind.length - 3} more` : ""}, which ${leftBehind.length === 1 ? "is" : "are"} still there` : null;
+  const changedValues = report?.verdict === "pass" && contract && since.base ? askedTestChanges(repoRoot2, since.base, contract, changesList.map((c) => c.path), snap?.commit) : [];
+  const valueLine = (c) => c.kind === "values" ? `${c.path} (${c.changes.slice(0, 3).map((x) => `${x.input}: ${x.from} -> ${x.to}`).join("; ")}${c.changes.length > 3 ? `; and ${c.changes.length - 3} more` : ""})` : `${c.path} (Replume cannot read this test as cases, or a case went away: read its diff)`;
+  const valueWhy = changedValues.length ? `an expected value ${changedValues.every((c) => c.kind === "values") ? "" : "may have "}changed in ${changedValues.map(valueLine).join(", ")}` : null;
+  const valueConfirm = changedValues.length ? changedValues.map((c) => c.confirm).join(" && ") : void 0;
+  const incompleteWhy = (copyLimit ? problem : null) ?? committedWhy ?? (outsideReason ? null : conflictWhy) ?? valueWhy ?? leftWhy ?? (fail2 ? null : incomplete) ?? outsideReason ?? ignoredWhy ?? (scriptBlind && !fail2 ? blindLine(blindScripts[0]) : null) ?? (shrink && !fail2 ? shrink : null);
   const testRun = report?.scenarios.find((r) => r.id === "test_command");
   const preCount = report?.preExistingFailures?.length ?? 0;
   const preScenarioCount = report?.preExistingScenarios?.length ?? 0;
@@ -13875,18 +14543,19 @@ ${run.stderrTail}`) : null;
   const unchangedSince = (p) => {
     if (!base4 || !snap) return false;
     try {
-      execFileSync29("git", ["diff", "--quiet", base4, snap.commit, "--", p], { cwd: repoRoot2, stdio: "ignore" });
+      execFileSync30("git", ["diff", "--quiet", base4, snap.commit, "--", p], { cwd: repoRoot2, stdio: "ignore" });
       return true;
     } catch {
       return false;
     }
   };
-  const askedUnchanged = report && !noChanges ? asked.filter(unchangedSince) : [];
+  const wholeSuite = contract ? testEditsAskedFor(contract.task, repoRoot2, void 0, report?.baseCommit ?? void 0).why : {};
+  const askedUnchanged = report && !noChanges ? asked.filter((p) => wholeSuite[p] !== WHOLE_SUITE_WHY).filter(unchangedSince) : [];
   const notDone = status === "PASS" && askedUnchanged.length ? `PASS - not done: the task asks to change ${askedUnchanged.slice(0, 3).join(", ")}, which ${askedUnchanged.length === 1 ? "is" : "are"} unchanged` : null;
   const verdictText = status === "NOT VERIFIED" ? "NOT VERIFIED" : taskRed ? taskRed : notDone ? notDone : status === "PASS" && elsewhere ? `PASS - ${elsewhere.text}` : status === "NO CHANGES" ? `NO CHANGES \u2014 ${noChangesWhy}` : status === "PASS" && previous.length ? `PASS (${previous.join("; ")})` : void 0;
   const stem2 = sessionId2.replace(/[^A-Za-z0-9_-]/g, "") || "session";
-  const reportPath = join48(REPLUME_DIR, "reports", `${stem2}.md`);
-  const htmlPath = join48(REPLUME_DIR, "reports", `${stem2}.html`);
+  const reportPath = join49(REPLUME_DIR, "reports", `${stem2}.md`);
+  const htmlPath = join49(REPLUME_DIR, "reports", `${stem2}.html`);
   const head0 = headline(status, report, steps, status === "NO CHANGES" ? noChangesWhy : noCommit ? NO_COMMIT : incompleteWhy, problem && !noCommit && !copyLimit ? `could not verify: ${cell(problem, 160)}` : copyLimit ? "nothing verified" : void 0);
   const head = elsewhere && status === "PASS" ? head0.replace(/^PASS/, `PASS - ${elsewhere.text}`) : head0;
   const facts2 = { config, repoRoot: repoRoot2, sessionId: sessionId2, events, snap, report };
@@ -13902,7 +14571,9 @@ ${run.stderrTail}`) : null;
     noCommit,
     snapshotFailed: since.unavailable ?? null,
     unseenChanges: outside.length > 0 || !!scriptBlind,
-    shrink
+    shrink,
+    askedLeft: leftWhy && incompleteWhy === leftWhy ? leftBehind : void 0,
+    expectationConfirm: valueWhy && incompleteWhy === valueWhy ? valueConfirm : void 0
   });
   const next = nextLine({ status, recovery: nextClass.recovery }, { uncommitted: !!snap?.snapshot });
   const rt = runtime ? {
@@ -13912,6 +14583,7 @@ ${run.stderrTail}`) : null;
     ...runtime.evidencePaths.length ? { screenshots: runtime.evidencePaths } : {}
   } : { status: "not_checked", reason: config.auto.runtime === "off" ? "the runtime check is off (auto.runtime: off)" : report ? "the runtime check did not run" : "nothing was verified, so no runtime check ran" };
   const extras = {
+    ...changedValues.length ? { askedTestChanges: changedValues.flatMap((c) => [...c.changes.map((x) => `${c.path}: ${x.input}: was ${x.from}, now ${x.to}`), ...c.kind === "other" ? [`${c.path}: cannot be read as cases, or a case went away. Its diff:`, ...c.diff.map((l) => `\`${l}\``)] : []]) } : {},
     verdict: status === "PASS" ? "pass" : status === "FAIL" ? "fail" : "incomplete",
     ...status === "INCOMPLETE" && incompleteWhy ? { verdictReason: incompleteWhy } : status === "FAIL" && report ? { verdictReason: visibleFailureReason(report) } : {},
     // CHECK_NOT_RUN is only for a check that did not run
@@ -13963,14 +14635,14 @@ ${differs}\`\`\`
 ${renderReport(report).replace(/^Verdict: /, "Check run on the snapshot: ")}
 \`\`\`
 ` : rendered.markdown;
-  mkdirSync24(join48(repoRoot2, REPLUME_DIR, "reports"), { recursive: true });
-  writeFileSync24(join48(repoRoot2, reportPath), redactLedgerText(full, repoRoot2));
-  writeFileSync24(join48(repoRoot2, htmlPath), redactLedgerText(rendered.html, repoRoot2));
+  mkdirSync25(join49(repoRoot2, REPLUME_DIR, "reports"), { recursive: true });
+  writeFileSync25(join49(repoRoot2, reportPath), redactLedgerText(full, repoRoot2));
+  writeFileSync25(join49(repoRoot2, htmlPath), redactLedgerText(rendered.html, repoRoot2));
   try {
     const treeOf = (c) => {
       if (!c) return null;
       try {
-        return execFileSync29("git", ["rev-parse", `${c}^{tree}`], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        return execFileSync30("git", ["rev-parse", `${c}^{tree}`], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
       } catch {
         return null;
       }
@@ -13988,7 +14660,9 @@ ${renderReport(report).replace(/^Verdict: /, "Check run on the snapshot: ")}
       noCommit,
       snapshotFailed: since.unavailable ?? null,
       unseenChanges: unseen,
-      shrink
+      shrink,
+      askedLeft: leftWhy && incompleteWhy === leftWhy ? leftBehind : void 0,
+      expectationConfirm: valueWhy && incompleteWhy === valueWhy ? valueConfirm : void 0
     });
     writeSummary(repoRoot2, stem2, { v: 1, session: sessionId2, status, verdict_line: (redactLedgerText(full, repoRoot2).split("\n")[0] ?? "").replace(/^Verdict:\s*/, ""), ...cls, ...ignoredNow?.changes.length ? { ignored_changed: ignoredNow.changes.map((c) => c.path) } : {}, tree: { verified: treeOf(snap?.commit), task_start: treeOf(base4) }, report: reportPath, generated_at: (/* @__PURE__ */ new Date()).toISOString() });
   } catch {
@@ -14084,7 +14758,7 @@ function reviewAtStop(i) {
       ...withRenames(i.repoRoot, testEditsAskedFor(i.contract.task, i.repoRoot, void 0, base4).paths, base4),
       ...changedFiles.filter((p) => {
         try {
-          return isConfirmed(i.repoRoot, p, readFileSync41(join49(i.repoRoot, p), "utf8"));
+          return isConfirmed(i.repoRoot, p, readFileSync42(join50(i.repoRoot, p), "utf8"));
         } catch {
           return false;
         }
@@ -14109,15 +14783,15 @@ import { join as join54 } from "path";
 import { homedir as homedir5 } from "os";
 
 // src/core/auto-contract.ts
-import { execFileSync as execFileSync30 } from "child_process";
-import { existsSync as existsSync37 } from "fs";
-import { join as join50 } from "path";
-import { readFileSync as readFileSync42 } from "fs";
+import { execFileSync as execFileSync31 } from "child_process";
+import { existsSync as existsSync38 } from "fs";
+import { join as join51 } from "path";
+import { readFileSync as readFileSync43 } from "fs";
 var MAX_AUTO_DIRS = 12;
 var MAX_IMPORT_ALLOW = 6;
 function ensureAutoContract(input) {
   const mode = readMode(input.repoRoot);
-  const existing = existsSync37(contractPath(input.repoRoot)) ? loadContract(contractPath(input.repoRoot)) : null;
+  const existing = existsSync38(contractPath(input.repoRoot)) ? loadContract(contractPath(input.repoRoot)) : null;
   if (mode !== "auto" || !input.prompt.trim()) return { created: false, contractId: existing?.id ?? null, assumptions: [] };
   const events = readEvents(ledgerPath(input.repoRoot)).events;
   const autoRaw = (e) => e.raw ?? {};
@@ -14137,7 +14811,9 @@ function ensureAutoContract(input) {
   for (const [p, why] of Object.entries(testEditsAskedFor(input.prompt.trim(), input.repoRoot).why))
     notes.push(`allow change "${p}": ${why}; the task asks to change it (skip, removed tests or assertions and other weakening are still refused)`);
   const allow = plan.allow;
-  const protect = plan.protect;
+  const asked = testEditsAskedFor(input.prompt.trim(), input.repoRoot).paths;
+  const tracked2 = trackedFiles(input.repoRoot);
+  const protect = [...new Set(plan.protect.flatMap((g) => asked.includes(g) ? [] : /[*?[]/.test(g) && asked.some((p) => matchesAny(p, [g])) ? tracked2.filter((f) => matchesAny(f, [g]) && !asked.includes(f)) : [g]))];
   const confirmed = { ...contract, allow, protect, status: "confirmed" };
   const path = contractPath(input.repoRoot);
   writeContract(path, confirmed);
@@ -14155,6 +14831,10 @@ function ensureAutoContract(input) {
     recordAskedTests(input.repoRoot, confirmed.id, testEditsAskedFor(input.prompt.trim(), input.repoRoot).paths);
   } catch {
   }
+  try {
+    recordAskedDeletions(input.repoRoot, confirmed.id, deletionsAskedFor(input.prompt.trim(), input.repoRoot));
+  } catch {
+  }
   try {
     recordIgnoredState(input.repoRoot, confirmed.id);
   } catch {
@@ -14164,7 +14844,7 @@ function ensureAutoContract(input) {
     snap.unavailable ? `snapshot_unavailable: ${snap.unavailable}; changes outside captured tools will NOT be checked, and Replume will not tell the agent to restore files to HEAD` : `worktree snapshot ${snap.commit ?? "none"}${snap.dirty ? " (dirty tree)" : " (clean tree)"}`,
     ...notes
   ];
-  if (existsSync37(join50(input.repoRoot, REPLUME_DIR))) {
+  if (existsSync38(join51(input.repoRoot, REPLUME_DIR))) {
     appendEvent(ledgerPath(input.repoRoot), {
       agent: input.agent ?? "claude-code",
       agentVersion: null,
@@ -14182,7 +14862,7 @@ function ensureAutoContract(input) {
   }
   const askedTests = testEditsAskedFor(confirmed.task, input.repoRoot).paths;
   const named = protectedTestsNamedInTask(confirmed.task, confirmed.protect).filter((p) => !askedTests.includes(p));
-  if (named.length && existsSync37(join50(input.repoRoot, REPLUME_DIR))) {
+  if (named.length && existsSync38(join51(input.repoRoot, REPLUME_DIR))) {
     appendEvent(ledgerPath(input.repoRoot), {
       agent: input.agent ?? "claude-code",
       agentVersion: null,
@@ -14216,14 +14896,14 @@ function ensureAutoContractLate(input) {
   const events = readEvents(ledgerPath(input.repoRoot)).events;
   const mine = events.filter((e) => e.sessionId === input.sessionId);
   if (mine.some((e) => e.raw?.autoContract === true)) return "have";
-  const existing = existsSync37(contractPath(input.repoRoot)) ? loadContract(contractPath(input.repoRoot)) : null;
+  const existing = existsSync38(contractPath(input.repoRoot)) ? loadContract(contractPath(input.repoRoot)) : null;
   const madeByAuto = existing && events.some((e) => e.raw?.autoContract === true && e.raw.contractId === existing.id);
   if (existing && !madeByAuto) return "have";
   const prompt2 = firstPromptOf(mine, input.sessionId);
   if (prompt2) return ensureAutoContract({ repoRoot: input.repoRoot, sessionId: input.sessionId, prompt: prompt2, agent: input.agent, late: input.hook }).created ? "created" : "have";
   const fromAgent = input.fallbackPrompt?.() ?? null;
   if (fromAgent) return ensureAutoContract({ repoRoot: input.repoRoot, sessionId: input.sessionId, prompt: fromAgent, agent: input.agent, late: `${input.hook}, prompt read from the agent's transcript` }).created ? "created" : "have";
-  if (!mine.some((e) => e.rule === AUTO_CONTRACT_UNAVAILABLE_RULE) && existsSync37(join50(input.repoRoot, REPLUME_DIR))) {
+  if (!mine.some((e) => e.rule === AUTO_CONTRACT_UNAVAILABLE_RULE) && existsSync38(join51(input.repoRoot, REPLUME_DIR))) {
     appendEvent(ledgerPath(input.repoRoot), {
       agent: input.agent,
       agentVersion: null,
@@ -14272,9 +14952,20 @@ function autoScope(i) {
     if (matchesAny(probe, allow) || allow.includes(p) || matchesAny(probe, protect) || isNeverAllowed(probe) || isTestFile(probe) || isTestSupportFile(probe)) continue;
     allow.push(p);
     notes.push(`allow "${p}": the task names it`);
+    const dir2 = p.endsWith(".py") && p.includes("/") ? p.slice(0, p.lastIndexOf("/")) : null;
+    const init = dir2 ? `${dir2}/__init__.py` : null;
+    if (dir2 && init && !i.files.some((f) => f.startsWith(`${dir2}/`)) && !matchesAny(init, allow) && !matchesAny(init, protect) && !allow.includes(init)) {
+      allow.push(init);
+      notes.push(`allow "${init}": the package file of ${p}, which the task names, in a folder that does not exist yet`);
+    }
+  }
+  for (const f of deletionsAskedFor(i.task, i.repoRoot, i.files).files) {
+    if (matchesAny(f, allow) || matchesAny(f, protect) || isNeverAllowed(f)) continue;
+    allow.push(f);
+    notes.push(`allow "${f}": the task asks to delete it`);
   }
   const taskWords = words4(i.task);
-  const tests = protect.filter((p) => !/[*?[]/.test(p) && isTestFile(p) && existsSync37(join50(i.repoRoot, p)));
+  const tests = protect.filter((p) => !/[*?[]/.test(p) && isTestFile(p) && existsSync38(join51(i.repoRoot, p)));
   const failing = new Set((i.failingTests ?? []).map(normalizeRel));
   const relevant = tests.filter((t) => named(t) || failing.has(t) || taskWords.has(stemOf(t)) || importedSources(i.repoRoot, t).some(named));
   const reasonFor = (t) => named(t) ? "the task names it" : failing.has(t) ? "it fails now" : taskWords.has(stemOf(t)) ? `its name matches the task word "${stemOf(t)}"` : "it imports a file the task names";
@@ -14318,13 +15009,13 @@ function autoScope(i) {
 }
 var AUTO_ALLOW_EXTENDED_RULE = "auto_allow_extended";
 function failingProtectedTests(repoRoot2, protect, output) {
-  const tests = protect.filter((p) => !/[*?[]/.test(p) && isTestFile(p) && existsSync37(join50(repoRoot2, p)));
+  const tests = protect.filter((p) => !/[*?[]/.test(p) && isTestFile(p) && existsSync38(join51(repoRoot2, p)));
   const names3 = failingTestNames(output);
   return tests.filter((t) => {
-    if (output.includes(t) || output.includes(join50(repoRoot2, t))) return true;
+    if (output.includes(t) || output.includes(join51(repoRoot2, t))) return true;
     let text = "";
     try {
-      text = readFileSync42(join50(repoRoot2, t), "utf8");
+      text = readFileSync43(join51(repoRoot2, t), "utf8");
     } catch {
       return false;
     }
@@ -14333,7 +15024,7 @@ function failingProtectedTests(repoRoot2, protect, output) {
 }
 function extendAutoAllowForFailures(i) {
   const path = contractPath(i.repoRoot);
-  const c = existsSync37(path) ? loadContract(path) : null;
+  const c = existsSync38(path) ? loadContract(path) : null;
   if (!c || c.status === "draft") return { added: [], notes: [] };
   const events = readEvents(ledgerPath(i.repoRoot)).events;
   const madeByAuto = events.some((e) => (e.raw ?? {}).autoContract === true && (e.raw ?? {}).contractId === c.id);
@@ -14376,7 +15067,7 @@ function extendAutoAllowForFailures(i) {
 }
 function modifiedNow(repoRoot2) {
   try {
-    const out = execFileSync30("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const out = execFileSync31("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd: repoRoot2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     const recs = out.split("\0").filter(Boolean);
     const paths = [];
     for (let i = 0; i < recs.length; i++) {
@@ -14390,125 +15081,6 @@ function modifiedNow(repoRoot2) {
   }
 }
 
-// src/core/shell-observe.ts
-import { execFileSync as execFileSync31 } from "child_process";
-import { createHash as createHash9 } from "crypto";
-import { existsSync as existsSync38, lstatSync as lstatSync7, mkdirSync as mkdirSync25, readFileSync as readFileSync43, rmSync as rmSync14, writeFileSync as writeFileSync25 } from "fs";
-import { tmpdir as tmpdir11 } from "os";
-import { join as join51, resolve as resolve6 } from "path";
-var MAX_TRACKED = 5e3;
-var SKIP2 = /^(\.claude|\.cursor|\.codex|\.git)\/|^\.replume\/(?!config$)/;
-function needsTreeCompare(a) {
-  if (a.kind !== "command" || !a.command) return false;
-  if (a.tool === "PowerShell") return true;
-  if (a.writeTargetNotParsed) return true;
-  const code2 = stripShellComments(a.command);
-  return INLINE_CODE.test(code2) || unobservable(code2);
-}
-var git9 = (cwd, args, input) => execFileSync31("git", ["--no-optional-locks", ...args], { cwd, encoding: "utf8", input, stdio: [input === void 0 ? "ignore" : "pipe", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 });
-function blobsOnDisk(top, paths) {
-  const out = /* @__PURE__ */ new Map();
-  const files = paths.filter((p) => {
-    try {
-      return lstatSync7(join51(top, p)).isFile();
-    } catch {
-      return false;
-    }
-  });
-  for (const p of paths) out.set(p, null);
-  if (!files.length) return out;
-  const ids = git9(top, ["hash-object", "--stdin-paths"], files.join("\n") + "\n").trim().split("\n");
-  files.forEach((p, i) => out.set(p, ids[i] ?? null));
-  return out;
-}
-function where(repoRoot2) {
-  const top = git9(repoRoot2, ["rev-parse", "--show-toplevel"]).trim();
-  const prefix = git9(repoRoot2, ["rev-parse", "--show-prefix"]).trim();
-  return { top, prefix };
-}
-function changedNow(repoRoot2) {
-  const { top, prefix } = where(repoRoot2);
-  let head = null;
-  try {
-    head = git9(top, ["rev-parse", "--verify", "-q", "HEAD"]).trim() || null;
-  } catch {
-    head = null;
-  }
-  const recs = git9(top, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--no-renames", "--", prefix ? prefix : "."]).split("\0").filter(Boolean);
-  if (recs.length > MAX_TRACKED) return null;
-  const paths = recs.map((r) => r.slice(3)).filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length)).filter((p) => !SKIP2.test(p));
-  return { top, prefix, head, paths };
-}
-function treeState(repoRoot2) {
-  try {
-    const now = changedNow(repoRoot2);
-    if (!now) return null;
-    const blobs = blobsOnDisk(now.top, now.paths.map((p) => now.prefix + p));
-    return { head: now.head, files: Object.fromEntries(now.paths.map((p) => [p, blobs.get(now.prefix + p) ?? null])) };
-  } catch {
-    return null;
-  }
-}
-function changedSince2(repoRoot2, before) {
-  try {
-    const now = changedNow(repoRoot2);
-    if (!now) return [];
-    const all = [.../* @__PURE__ */ new Set([...Object.keys(before.files), ...now.paths])].filter((p) => !SKIP2.test(p)).sort();
-    const after = blobsOnDisk(now.top, all.map((p) => now.prefix + p));
-    const unlisted = all.filter((p) => !(p in before.files));
-    const inHead = /* @__PURE__ */ new Map();
-    if (before.head && unlisted.length) {
-      const text = git9(now.top, ["ls-tree", "-z", before.head, "--", ...unlisted.map((p) => now.prefix + p)]);
-      for (const rec of text.split("\0").filter(Boolean)) {
-        const m = /^\d+ blob ([0-9a-f]+)\t(.+)$/.exec(rec);
-        if (m && m[2].startsWith(now.prefix)) inHead.set(m[2].slice(now.prefix.length), m[1]);
-      }
-    }
-    const out = [];
-    for (const p of all) {
-      const b = p in before.files ? before.files[p] : inHead.get(p) ?? null;
-      const a = after.get(now.prefix + p) ?? null;
-      if (a !== b) out.push({ path: p, before: b, after: a });
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-var sha = (s, n3 = 16) => createHash9("sha1").update(s).digest("hex").slice(0, n3);
-var stateFile = (repoRoot2, sessionId2, toolUseId) => join51(tmpdir11(), "replume-tree", sha(resolve6(repoRoot2), 12), sha(sessionId2, 12), `${sha(toolUseId, 20)}.json`);
-function rememberTree(repoRoot2, sessionId2, toolUseId) {
-  if (!toolUseId) return false;
-  const state = treeState(repoRoot2);
-  if (!state) return false;
-  try {
-    const f = stateFile(repoRoot2, sessionId2, toolUseId);
-    mkdirSync25(join51(f, ".."), { recursive: true });
-    writeFileSync25(f, JSON.stringify(state));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function takeTreeChanges(repoRoot2, sessionId2, toolUseId) {
-  if (!toolUseId) return null;
-  const f = stateFile(repoRoot2, sessionId2, toolUseId);
-  let state;
-  try {
-    if (!existsSync38(f)) return null;
-    state = JSON.parse(readFileSync43(f, "utf-8"));
-  } catch {
-    return null;
-  } finally {
-    rmSync14(f, { force: true });
-  }
-  if (!state || typeof state.files !== "object" || state.files === null) return null;
-  return changedSince2(repoRoot2, state);
-}
-function forgetTree(repoRoot2, sessionId2, toolUseId) {
-  if (toolUseId) rmSync14(stateFile(repoRoot2, sessionId2, toolUseId), { force: true });
-}
-
 // src/supervisor/types.ts
 var RANK2 = { ok: 0, steer: 1, block: 2 };
 var MAX_MESSAGE_CHARS = 1e3;
@@ -14664,11 +15236,11 @@ function doneMessage(s, allow = [], mode = "approve") {
 import { createHash as createHash10 } from "crypto";
 import { existsSync as existsSync40, mkdirSync as mkdirSync26, readFileSync as readFileSync45, rmSync as rmSync15, statSync as statSync9, writeFileSync as writeFileSync26 } from "fs";
 import { tmpdir as tmpdir12 } from "os";
-import { dirname as dirname17, join as join53, resolve as resolve7 } from "path";
+import { dirname as dirname17, join as join53, resolve as resolve8 } from "path";
 var STEER_RULE_PREFIX = "supervisor_";
 var steerRule = (source) => `${STEER_RULE_PREFIX}${source}`;
 var MAX_FILE_BYTES = 3e5;
-var stashDir = (repoRoot2, sessionId2) => join53(tmpdir12(), "replume-before", createHash10("sha1").update(resolve7(repoRoot2)).digest("hex").slice(0, 12), createHash10("sha1").update(sessionId2).digest("hex").slice(0, 12));
+var stashDir = (repoRoot2, sessionId2) => join53(tmpdir12(), "replume-before", createHash10("sha1").update(resolve8(repoRoot2)).digest("hex").slice(0, 12), createHash10("sha1").update(sessionId2).digest("hex").slice(0, 12));
 var stashFile = (repoRoot2, sessionId2, rel3, toolUseId) => join53(stashDir(repoRoot2, sessionId2), createHash10("sha1").update(`${toolUseId ?? ""}\0${rel3}`).digest("hex").slice(0, 20) + ".json");
 function readText(abs) {
   try {
@@ -14781,6 +15353,7 @@ function afterWrite(ctx, input, events, extraCandidates = []) {
     if (before === null || after === null || before === after) continue;
     const base4 = baseCommitOf(ctx.repoRoot);
     if (base4 && fileAt(ctx.repoRoot, base4, rel3) === after) continue;
+    if (mode === "auto" && ctx.contract && askedTestsNow(ctx.repoRoot, ctx.contract).includes(rel3) && sameInputsKept(before, after, rel3)) continue;
     if (bypassApplies(rel3)) titles ??= workingTreeTestTitles(ctx.repoRoot);
     const w = testWeakening(before, after, rel3, { mode, allow: ctx.contract?.allow, taskText: anchor.text || void 0, recentTestOutput: recent, testTitles: titles });
     if (w.severity !== "ok" && w.steer) candidates.push({ source: "weakening", severity: w.severity, message: w.steer, detail: rel3 });
@@ -14788,7 +15361,8 @@ function afterWrite(ctx, input, events, extraCandidates = []) {
   }
   const stepIndex = events.map((e) => e.type === "file_edit" || e.type === "command" && (e.raw?.writes?.length ?? 0) > 0).lastIndexOf(true);
   if (stepIndex >= 0) {
-    const d = driftScore(events[stepIndex], { task: anchor.text, allow: ctx.contract?.allow, testCommand, mode }, events.slice(0, stepIndex));
+    const askedDeletions = ctx.contract && mode === "auto" ? askedDeletionTargets(ctx.repoRoot, ctx.contract) : void 0;
+    const d = driftScore(events[stepIndex], { task: anchor.text, allow: ctx.contract?.allow, testCommand, mode, askedDeletions }, events.slice(0, stepIndex));
     if (d.nudge) candidates.push({ source: "drift", severity: "warn", message: d.nudge, detail: d.step.label });
     if (d.nudge) driftExtra.outOfScope = d.outOfScopeWrites;
   }
@@ -14814,7 +15388,9 @@ function deliverPendingJudge(ctx, events) {
 function claimCandidate(ctx, events, lastAssistantMessage, stopHookActive) {
   if (!ctx.config.supervisor.checks || stopHookActive || !lastAssistantMessage.trim()) return null;
   if (taskClosed(events)) return null;
-  const r = claimCheck(lastAssistantMessage, events, { testCommand: ctx.contract?.test_command });
+  const base4 = baseCommitOf(ctx.repoRoot);
+  const changedFromBaseNow = base4 ? [...changedFromBase(ctx.repoRoot, base4)?.keys() ?? []] : [];
+  const r = claimCheck(lastAssistantMessage, events, { testCommand: ctx.contract?.test_command, changedFromBase: changedFromBaseNow });
   return r.message ? { source: "claim", severity: "warn", message: r.message, detail: r.mismatches[0]?.kind } : null;
 }
 
@@ -14857,7 +15433,7 @@ function ranToEvent(ran, session) {
 
 // src/agents/claude/payload.ts
 import { existsSync as existsSync41, readFileSync as readFileSync46 } from "fs";
-import { isAbsolute as isAbsolute5, resolve as resolve8 } from "path";
+import { isAbsolute as isAbsolute5, resolve as resolve9 } from "path";
 function parsePayload(text) {
   const x = JSON.parse(text);
   if (typeof x !== "object" || x === null) throw new Error("hook payload is not a JSON object");
@@ -14876,7 +15452,7 @@ function readIfExists(path) {
 }
 function absolutePathsIn(command) {
   return (command.match(/(?<![\w.:/])(?:\/|~\/)[\w.@+-]+(?:\/[\w.@+-]*)*(?![\w.@+(/-])/g) ?? []).map(
-    (p) => p.startsWith("~/") ? resolve8(process.env.HOME ?? "/", p.slice(2)) : p
+    (p) => p.startsWith("~/") ? resolve9(process.env.HOME ?? "/", p.slice(2)) : p
   );
 }
 function toProposedAction(p, repoRoot2) {
@@ -14892,7 +15468,7 @@ function toProposedAction(p, repoRoot2) {
   const pending = [];
   const abs = (fp) => {
     const h = expandHome(fp);
-    return isAbsolute5(h) || h.startsWith("~") ? h : resolve8(p.cwd, h);
+    return isAbsolute5(h) || h.startsWith("~") ? h : resolve9(p.cwd, h);
   };
   switch (tool) {
     case "Bash":
@@ -15110,7 +15686,8 @@ function preToolUse(p, repoRoot2, env, deps) {
   if (action.kind === "edit" || action.kind === "write" || action.kind === "command" && action.paths.length) {
     if (loadConfig(repoRoot2).supervisor.checks) stashBefore(repoRoot2, p.session_id, action.paths, p.tool_use_id);
   }
-  const comparing = needsTreeCompare(action) && rememberTree(repoRoot2, p.session_id, p.tool_use_id);
+  if (action.kind === "command") landTreeChanges(repoRoot2, baseCommitOf(repoRoot2), { agent: "claude-code", sessionId: p.session_id });
+  const comparing = !baseCommitOf(repoRoot2) && needsTreeCompare(action) && rememberTree(repoRoot2, p.session_id, p.tool_use_id);
   let session = readEvents(ledger).events.filter((e) => e.sessionId === p.session_id);
   if (contractFromTranscript(p, repoRoot2, session, "PreToolUse")) session = readEvents(ledger).events.filter((e) => e.sessionId === p.session_id);
   return andThen(decide2(p, repoRoot2, { kind: "action", action }, session, env, deps), ({ result: result2, contract }) => {
@@ -15169,7 +15746,7 @@ async function waitForAutoVerdict(repoRoot2, sessionId2) {
   while (Date.now() < deadline) {
     const verdict = currentVerdict(readEvents(ledgerPath(repoRoot2)).events.filter((e) => e.sessionId === sessionId2));
     if (verdict) return verdict;
-    await new Promise((resolve17) => setTimeout(resolve17, 100));
+    await new Promise((resolve18) => setTimeout(resolve18, 100));
   }
   return null;
 }
@@ -15230,6 +15807,7 @@ function recordStopChecks(p, ledger, results, contractId, lastAssistantMessage,
 function stop(p, repoRoot2, env, deps) {
   const startedAtMs = Date.now();
   const ledger = ledgerPath(repoRoot2);
+  landTreeChanges(repoRoot2, baseCommitOf(repoRoot2), { agent: "claude-code", sessionId: p.session_id });
   let session = readEvents(ledger).events.filter((e) => e.sessionId === p.session_id);
   if (contractFromTranscript(p, repoRoot2, session, "Stop")) session = readEvents(ledger).events.filter((e) => e.sessionId === p.session_id);
   const lastAssistantMessage = typeof p.last_assistant_message === "string" ? p.last_assistant_message : "";
@@ -15361,8 +15939,10 @@ function postToolUse(p, repoRoot2, failed) {
   const exitMatch = error ? /^Exit code (\d+)/.exec(error) : null;
   const wctx = wireContext(p, repoRoot2);
   const tail = action.kind === "command" && action.command && isTestCommand(action.command, wctx.contract?.test_command) ? outputTailOf(failed ? error : p.tool_response, failed ? null : error) : null;
-  const changes = action.kind === "command" ? takeTreeChanges(repoRoot2, p.session_id, p.tool_use_id) : null;
-  const observed = action.kind === "command" ? observedWrites(action, changes) : null;
+  const fromBase = newTreeChanges(repoRoot2, baseCommitOf(repoRoot2));
+  const changes = action.kind === "command" ? fromBase ?? takeTreeChanges(repoRoot2, p.session_id, p.tool_use_id) : null;
+  const observed = action.kind !== "command" ? null : fromBase ? writesFromTree(fromBase, [...action.paths, ...action.certainPaths ?? [], ...action.managedWrites ?? []]) : observedWrites(action, changes);
+  const alsoChanged = action.kind !== "command" && fromBase ? fromBase.filter((c) => !action.paths.includes(c.path)) : [];
   const confirmed = failed && changes ? changes.map((c) => c.path) : null;
   appendEvent(ledgerPath(repoRoot2), {
     ...base3(p, type),
@@ -15389,8 +15969,17 @@ function postToolUse(p, repoRoot2, failed) {
       } : {}
     }
   });
+  if (alsoChanged.length) {
+    const files = alsoChanged.map((c) => c.path);
+    appendEvent(ledgerPath(repoRoot2), { ...base3(p, "command"), tool: action.tool, paths: files, command: null, summary: `${action.tool} also changed ${files.join(", ")}`, rule: null, action: "ok", message: null, raw: { tool_use_id: p.tool_use_id ?? null, ok: true, treeSweep: true, ...writesFromTree(alsoChanged, []) } });
+  }
   const commandPaths = action.kind !== "command" ? [] : failed ? (action.certainPaths ?? []).filter((path) => confirmed?.includes(path)) : action.certainPaths ?? [];
-  const wrote = action.kind === "command" ? commandPaths.length > 0 : !failed && (action.kind === "edit" || action.kind === "write");
+  const askedInRun = action.kind === "command" && wctx.contract && wctx.config.mode === "auto" && fromBase ? fromBase.map((c) => c.path).filter((f) => askedTestsNow(repoRoot2, wctx.contract).includes(f)) : [];
+  const afterRun = askedInRun.flatMap((f) => {
+    const m = judgeAskedAfterRun(repoRoot2, wctx.contract, f);
+    return m ? [{ source: "weakening", severity: "warn", message: m, detail: f }] : [];
+  });
+  const wrote = action.kind === "command" ? commandPaths.length > 0 || afterRun.length > 0 : !failed && (action.kind === "edit" || action.kind === "write");
   if (!wctx.config.supervisor.checks) return QUIET;
   if (!wrote) {
     if (!wctx.config.judge.enabled) return QUIET;
@@ -15400,7 +15989,7 @@ function postToolUse(p, repoRoot2, failed) {
   }
   const paths = action.kind === "command" ? commandPaths : action.paths;
   const events = readEvents(ledgerPath(repoRoot2)).events.filter((e) => e.sessionId === p.session_id);
-  const d = afterWrite(wctx, { paths, toolUseId: p.tool_use_id }, events);
+  const d = afterWrite(wctx, { paths, toolUseId: p.tool_use_id }, events, afterRun);
   if (!d.message) return QUIET;
   return { exitCode: 0, stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: d.message } }), stderr: "" };
 }
@@ -15541,7 +16130,7 @@ function handleClaudeHook(stdinText, env = process.env, deps = {}) {
 }
 
 // src/agents/cursor/handler.ts
-import { isAbsolute as isAbsolute8, relative as relative8, resolve as resolve9, sep as sep5 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative8, resolve as resolve10, sep as sep5 } from "path";
 
 // src/agents/cursor/adapter.ts
 import { relative as relative7, isAbsolute as isAbsolute6 } from "path";
@@ -16031,7 +16620,7 @@ function autoSessionEnd(i) {
 
 // src/agents/cursor/install.ts
 import { createHash as createHash11 } from "crypto";
-import { existsSync as existsSync43, mkdirSync as mkdirSync28, readFileSync as readFileSync48, renameSync, rmSync as rmSync16, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync28, readFileSync as readFileSync48, renameSync as renameSync2, rmSync as rmSync16, writeFileSync as writeFileSync27 } from "fs";
 import { dirname as dirname18, join as join57 } from "path";
 var CURSOR_HOOK_COMMAND = "replume hook cursor";
 var CURSOR_HOOK_EVENTS = [
@@ -16142,7 +16731,7 @@ function installCursorHooks(root, opts = {}) {
   }
   const temp = `${path}.replume-tmp`;
   writeFileSync27(temp, updated);
-  renameSync(temp, path);
+  renameSync2(temp, path);
   return { path, backupPath: existsSync43(backupPath) ? backupPath : null, added, updated: upgraded };
 }
 function uninstallCursorHooks(root) {
@@ -16204,7 +16793,7 @@ function handleCursorHook(stdinText, env = process.env, deps = {}) {
     const payload = JSON.parse(stdinText);
     if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("invalid payload");
     const raw6 = payload;
-    const root = resolve9(env.CURSOR_PROJECT_DIR ?? process.cwd());
+    const root = resolve10(env.CURSOR_PROJECT_DIR ?? process.cwd());
     ensureDependencyExcludes(root);
     const event = cursorHookToEvent(raw6, { id: newEventId(), ts: (/* @__PURE__ */ new Date()).toISOString(), repoRoot: root });
     if (!event) return { stdout: "{}", stderr: "", exitCode: 0 };
@@ -16273,6 +16862,7 @@ function handleCursorHook(stdinText, env = process.env, deps = {}) {
     for (const hit of evaluation?.hits ?? []) {
       appendEvent(ledger, sanitizeCursorLedgerEvent(ruleHitEvent(event, hit, { id: newEventId(), ts: (/* @__PURE__ */ new Date()).toISOString() }), root));
     }
+    if (["postToolUse", "afterShellExecution", "afterFileEdit"].includes(hookName)) landTreeChanges(root, baseCommitOf(root), { agent: "cursor", sessionId: event.sessionId });
     if (hookName === "sessionEnd") {
       const settings = cursorStopSettings(root);
       autoSessionEnd({ agent: "cursor", repoRoot: root, sessionId: event.sessionId, hookTimeoutSec: settings.timeoutSec, followupLimit: settings.loopLimit, base: { ...event, id: void 0, ts: void 0 }, sanitize, deps });
@@ -16296,10 +16886,10 @@ function handleCursorHook(stdinText, env = process.env, deps = {}) {
 import { execFileSync as execFileSync33 } from "child_process";
 import { createHash as createHash12 } from "crypto";
 import { existsSync as existsSync45, readFileSync as readFileSync50 } from "fs";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 
 // src/agents/codex/action.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 function codexAction(payload, root) {
   const tool = typeof payload.tool_name === "string" ? payload.tool_name : "unknown";
   const input = payload.tool_input && typeof payload.tool_input === "object" && !Array.isArray(payload.tool_input) ? payload.tool_input : {};
@@ -16309,7 +16899,7 @@ function codexAction(payload, root) {
   }
   if (tool === "apply_patch") {
     const rawPaths = [...command.matchAll(/^\*\*\* (?:Add File|Update File|Delete File|Move to): (.+)$/gm)].map((m) => m[1].trim());
-    const { inside, outside } = splitPaths(root, rawPaths.map((p) => resolve10(String(payload.cwd), p)));
+    const { inside, outside } = splitPaths(root, rawPaths.map((p) => resolve11(String(payload.cwd), p)));
     return {
       kind: "edit",
       tool,
@@ -16422,13 +17012,13 @@ function handleCodexHook(stdinText, deps = {}) {
     if (stdinText.length > 1024 * 1024) throw new Error("oversized hook input");
     const p = JSON.parse(stdinText);
     if (!object3(p) || !str4(p.session_id) || !str4(p.cwd) || !str4(p.hook_event_name)) throw new Error("invalid hook input");
-    const cwd = resolve11(str4(p.cwd));
+    const cwd = resolve12(str4(p.cwd));
     let root = cwd;
     try {
       root = execFileSync33("git", ["rev-parse", "--show-toplevel"], { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
     } catch {
     }
-    if (!existsSync45(resolve11(root, ".replume"))) return QUIET2;
+    if (!existsSync45(resolve12(root, ".replume"))) return QUIET2;
     ensureDependencyExcludes(root);
     const ledger = ledgerPath(root);
     const base4 = (type) => ({
@@ -16520,7 +17110,7 @@ ${stop2.message}${note}` }));
         rule: first?.rule ?? null,
         action: verdict.action,
         message: verdict.message,
-        raw: { ...raw6, beforeHashes: a.kind === "edit" || a.kind === "command" ? Object.fromEntries((a.kind === "edit" ? a.paths : raw6.writes ?? []).map((path) => [path, fileHash(resolve11(root, path))])) : void 0 }
+        raw: { ...raw6, beforeHashes: a.kind === "edit" || a.kind === "command" ? Object.fromEntries((a.kind === "edit" ? a.paths : raw6.writes ?? []).map((path) => [path, fileHash(resolve12(root, path))])) : void 0 }
       });
       for (const hit of verdict.hits) appendEvent(ledger, {
         ...base4("rule_hit"),
@@ -16554,10 +17144,10 @@ ${stop2.message}${note}` }));
     const result_ = exitKnown ? { ok: success } : fromOutput ? { ok: fromOutput.ok, okFrom: "output", exitUnknown: true } : { exitUnknown: true };
     const prior = readEvents(ledger).events.reverse().find((e) => e.type === "tool_pre" && e.raw?.tool_use_id === str4(p.tool_use_id));
     const before = prior?.raw?.beforeHashes;
-    const hashChanged = () => (raw6.writes ?? []).filter((path) => before && path in before && fileHash(resolve11(root, path)) !== before[path]);
+    const hashChanged = () => (raw6.writes ?? []).filter((path) => before && path in before && fileHash(resolve12(root, path)) !== before[path]);
     const writes = a.kind === "command" && !exitKnown ? { writes: hashChanged() } : a.kind === "command" && !success ? { contentConfirmed: hashChanged() } : {};
     const confirmed = writes.contentConfirmed ?? [];
-    const changed = a.paths.filter((path) => before && path in before && fileHash(resolve11(root, path)) !== before[path]);
+    const changed = a.paths.filter((path) => before && path in before && fileHash(resolve12(root, path)) !== before[path]);
     appendEvent(ledger, {
       ...base4("tool_post"),
       tool: a.tool,
@@ -16566,6 +17156,7 @@ ${stop2.message}${note}` }));
       summary: `${a.tool} completed`,
       raw: { ...raw6, ...result_ }
     });
+    landTreeChanges(root, baseCommitOf(root), { agent: "codex", sessionId: str4(p.session_id) });
     if (a.kind === "edit" && changed.length && (success || responseText.includes("Success."))) {
       for (const path of changed)
         appendEvent(ledger, {
@@ -16602,11 +17193,11 @@ ${stop2.message}${note}` }));
 // src/agents/copilot/handler.ts
 import { execFileSync as execFileSync34 } from "child_process";
 import { existsSync as existsSync46 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 
 // src/agents/copilot/action.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { basename as basename3, dirname as dirname20, isAbsolute as isAbsolute9, join as join59, relative as relative9, resolve as resolve12 } from "path";
+import { basename as basename3, dirname as dirname20, isAbsolute as isAbsolute9, join as join59, relative as relative9, resolve as resolve13 } from "path";
 var object4 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
 function parseToolArgs(toolArgs) {
   if (object4(toolArgs)) return toolArgs;
@@ -16636,7 +17227,7 @@ function real(path) {
 }
 function rel(repoRoot2, path) {
   const root = real(repoRoot2);
-  const abs = isAbsolute9(path) ? path : resolve12(root, path);
+  const abs = isAbsolute9(path) ? path : resolve13(root, path);
   const parent = real(dirname20(abs));
   const file3 = join59(parent, basename3(abs));
   const out = relative9(root, file3);
@@ -16717,13 +17308,13 @@ function handleCopilotHook(stdinText, deps = {}) {
     if (stdinText.length > 1024 * 1024) throw new Error("oversized hook input");
     const raw6 = JSON.parse(stdinText);
     if (!object5(raw6)) throw new Error("invalid hook input");
-    const cwd = resolve13(str5(raw6.cwd) || process.cwd());
+    const cwd = resolve14(str5(raw6.cwd) || process.cwd());
     let root = cwd;
     try {
       root = execFileSync34("git", ["rev-parse", "--show-toplevel"], { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
     } catch {
     }
-    if (!existsSync46(resolve13(root, ".replume"))) return QUIET3;
+    if (!existsSync46(resolve14(root, ".replume"))) return QUIET3;
     ensureDependencyExcludes(root);
     const sid = sessionId(raw6) || "copilot";
     const name = eventName(raw6);
@@ -16856,7 +17447,7 @@ import { execFileSync as execFileSync35 } from "child_process";
 import { existsSync as existsSync48, readFileSync as readFileSync52, rmSync as rmSync17, statSync as statSync10, writeFileSync as writeFileSync30 } from "fs";
 import { realpathSync as realpathSync4 } from "fs";
 import { tmpdir as tmpdir13 } from "os";
-import { basename as basename4, dirname as dirname22, isAbsolute as isAbsolute10, join as join61, relative as relative10, resolve as resolve14 } from "path";
+import { basename as basename4, dirname as dirname22, isAbsolute as isAbsolute10, join as join61, relative as relative10, resolve as resolve15 } from "path";
 var QUIET4 = { stdout: "", stderr: "", exitCode: 0 };
 var object6 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
 var str6 = (x) => typeof x === "string" ? x : "";
@@ -16870,7 +17461,7 @@ function real2(path) {
 }
 function rel2(repoRoot2, path) {
   const root = real2(repoRoot2);
-  const abs = isAbsolute10(path) ? path : resolve14(root, path);
+  const abs = isAbsolute10(path) ? path : resolve15(root, path);
   const parent = real2(dirname22(abs));
   const file3 = join61(parent, basename4(abs));
   const out = relative10(root, file3);
@@ -16911,11 +17502,11 @@ function resolveRoot(cwd, args, extra) {
   const top = gitTop(cwd);
   if (top) starts.push(top);
   const path = fileArg(args);
-  if (path) starts.push(isAbsolute10(path) ? path : resolve14(cwd, path));
+  if (path) starts.push(isAbsolute10(path) ? path : resolve15(cwd, path));
   const changed = extra.changed_paths;
   if (Array.isArray(changed)) {
     for (const item of changed) {
-      if (typeof item === "string" && item.trim()) starts.push(isAbsolute10(item) ? item : resolve14(cwd, item));
+      if (typeof item === "string" && item.trim()) starts.push(isAbsolute10(item) ? item : resolve15(cwd, item));
     }
   }
   for (const start of starts) {
@@ -16982,7 +17573,7 @@ function handleHermesHook(stdinText, deps = {}) {
     const raw6 = JSON.parse(stdinText);
     if (!object6(raw6)) throw new Error("invalid hook input");
     const name = str6(raw6.hook_event_name);
-    const cwd = resolve14(str6(raw6.cwd) || process.cwd());
+    const cwd = resolve15(str6(raw6.cwd) || process.cwd());
     const sid = str6(raw6.session_id) || "hermes";
     const extra = object6(raw6.extra) ? raw6.extra : {};
     const args = object6(raw6.tool_input) ? raw6.tool_input : {};
@@ -17194,7 +17785,7 @@ function writeBugBundle(root, version, now = /* @__PURE__ */ new Date()) {
 // src/core/share.ts
 import { appendFileSync as appendFileSync9, existsSync as existsSync49, mkdirSync as mkdirSync33, readFileSync as readFileSync54, readdirSync as readdirSync13, statSync as statSync12, writeFileSync as writeFileSync33 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join64, resolve as resolve15 } from "path";
+import { join as join64, resolve as resolve16 } from "path";
 var SHARE_ENDPOINT = "https://replume.dev";
 var SHARED_SECTIONS = [
   "What was asked",
@@ -17213,7 +17804,7 @@ var MAX_LINE = 600;
 function findReport(repoRoot2, arg) {
   const dir2 = join64(repoRoot2, ".replume", "reports");
   if (arg) {
-    const asPath = resolve15(repoRoot2, arg);
+    const asPath = resolve16(repoRoot2, arg);
     if (existsSync49(asPath) && statSync12(asPath).isFile()) return asPath;
     const byId = join64(dir2, `${arg.replace(/[^A-Za-z0-9_-]/g, "")}.md`);
     if (existsSync49(byId)) return byId;
@@ -17226,7 +17817,7 @@ function findReport(repoRoot2, arg) {
 var unescape2 = (s) => s.replace(/\\([\\`*_{}[\]()#+\-.!|>~])/g, "$1");
 function scrub2(text, repoRoot2) {
   let t = text;
-  if (repoRoot2) t = t.split(`${resolve15(repoRoot2)}/`).join("").split(resolve15(repoRoot2)).join(".");
+  if (repoRoot2) t = t.split(`${resolve16(repoRoot2)}/`).join("").split(resolve16(repoRoot2)).join(".");
   const home = homedir7();
   if (home && home.length > 1) t = t.split(home).join("~");
   t = t.replace(/(^|[\s(`"'=:])((?:~|\/(?:Users|home|private|tmp|var|opt|etc|root|Volumes|mnt))(?:\/[^\s`"')\]]*)?)/g, (_m, pre) => `${pre}<path>`).replace(/\b[A-Za-z]:\\[^\s`"')\]]*/g, "<path>");
@@ -17422,14 +18013,20 @@ function short(value, max) {
   }
   return `${out.replace(/\s+$/, "")}\u2026`;
 }
+function pathOfIntervention(e) {
+  const text = e.message ?? "";
+  const at = (p) => text.search(new RegExp(`(?<![\\w./-])${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w/-]|\\.\\w)`));
+  return e.paths.map((p) => [p, at(p)]).filter(([, i]) => i >= 0).sort((a, b) => a[1] - b[1])[0]?.[0] ?? e.paths[0] ?? "";
+}
 function line(e) {
   const raw6 = rawOf(e);
-  const path = e.paths[0] ?? "";
+  const path = e.action === "block" || e.action === "warn" ? pathOfIntervention(e) : e.paths[0] ?? "";
   const tool = clean2(e.tool ?? e.type);
   const target = clean2([tool, path || e.command || ""].filter(Boolean).join(" "));
   const summary = clean2(e.summary);
   const reason = clean2(e.message?.split(/\r?\n/)[0]).replace(/^\[[A-Z][A-Z0-9_]+\]\s*/, "").replace(/^Replume:\s*/i, "");
-  if (raw6.watchWrite === true) return { label: "WRITE", detail: summary, color: 36 };
+  if (raw6.watchWrite === true || raw6.treeSweep === true) return { label: "WRITE", detail: summary, color: 36 };
+  if (raw6.noResult === true) return { label: "NO RESULT", detail: `${target} (the agent reported no result; it may not have run)`, color: 33 };
   if (e.type === "rule_hit" && e.rule === "auto_verdict") {
     const verdict = clean2(raw6.status).toUpperCase() || "RESULT";
     const report = clean2(raw6.reportPath);
@@ -17507,11 +18104,14 @@ var callId = (e) => {
 var callKey = (e) => callId(e) ?? `k:${e.sessionId}:${e.tool ?? ""}|${e.command ?? ""}|${e.paths.join(",")}`;
 var isHeldPre = (e) => e.type === "tool_pre" && (e.action === "ok" || e.action === null || e.action === void 0);
 var isResult = (e) => (e.type === "command" || e.type === "file_edit" || e.type === "tool_post") && rawOf(e).by !== "replume";
-var flushes = (e) => e.type === "prompt" || e.type === "stop" || e.type === "rule_hit" && e.rule === "auto_verdict";
+var STOP_RULES = /* @__PURE__ */ new Set(["auto_verdict", "auto_stop_gate", "auto_incomplete", "changed_outside_tools"]);
+var flushes = (e) => e.type === "prompt" || e.type === "stop" || e.type === "rule_hit" && !!e.rule && STOP_RULES.has(e.rule);
+var NO_POST_HOOK = /* @__PURE__ */ new Set(["copilot", "hermes"]);
+var heldOut = (p) => NO_POST_HOOK.has(p.agent) ? p : { ...p, raw: { ...rawOf(p), noResult: true } };
 function formatEvents(events, state, opts = {}) {
   const out = [];
   const flushAll = () => {
-    for (const list5 of state.pending.values()) for (const p of list5) out.push(formatEvent(p, opts));
+    for (const list5 of state.pending.values()) for (const p of list5) out.push(formatEvent(heldOut(p), opts));
     state.pending.clear();
   };
   for (const e of events) {
@@ -18039,7 +18639,7 @@ function otherHookWarnings(home = process.env.HOME || homedir8()) {
 }
 
 // src/core/telemetry.ts
-import { appendFileSync as appendFileSync10, existsSync as existsSync52, mkdirSync as mkdirSync34, readdirSync as readdirSync14, readFileSync as readFileSync57, renameSync as renameSync2, rmSync as rmSync19, statSync as statSync14, writeFileSync as writeFileSync34 } from "fs";
+import { appendFileSync as appendFileSync10, existsSync as existsSync52, mkdirSync as mkdirSync34, readdirSync as readdirSync14, readFileSync as readFileSync57, renameSync as renameSync3, rmSync as rmSync19, statSync as statSync14, writeFileSync as writeFileSync34 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
 import { arch as osArch, homedir as homedir9, platform as osPlatform } from "os";
 import { dirname as dirname23, join as join67 } from "path";
@@ -18182,7 +18782,7 @@ function writeState(c, s) {
   const tmp = `${p}.${process.pid}.tmp`;
   writeFileSync34(tmp, `${JSON.stringify(s, null, 1)}
 `, { mode: 384 });
-  renameSync2(tmp, p);
+  renameSync3(tmp, p);
 }
 function enqueue(c, p) {
   if (!p || !isClosedPayload(p)) return;
@@ -18288,7 +18888,7 @@ async function flushTelemetry(c, fetchImpl = fetch) {
     if (sink(c)) return;
     const q = queuePath(c), claim = `${q}.${process.pid}.${c.now.getTime()}`;
     const stale = claimedFiles(c);
-    if (existsSync52(q)) renameSync2(q, claim);
+    if (existsSync52(q)) renameSync3(q, claim);
     const files = [...stale, ...existsSync52(claim) ? [claim] : []];
     const oldest = c.now.getTime() - QUEUE_MAX_AGE_MS;
     const batch = files.flatMap(readQueue).filter((p) => Date.parse(p.ts) >= oldest);
@@ -18439,11 +19039,11 @@ var summaryFor = (root, session) => {
 // src/cli.ts
 var CODEX_RETRUST_LINE = "Codex: Replume's hooks in .codex/hooks.json are new or changed; run /hooks in Codex to trust them (until then Codex skips them).";
 function readStdin() {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve18, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve17(data));
+    process.stdin.on("end", () => resolve18(data));
     process.stdin.on("error", reject);
   });
 }
@@ -18892,7 +19492,7 @@ async function executeInit(opts) {
   }
 }
 function boundedInitCheck(root, isolation) {
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     const child = spawn7(process.execPath, [...process.execArgv, process.argv[1], "__init-check-worker", ...isolation ? ["--isolation", isolation] : []], {
       cwd: root,
       env: process.env,
@@ -18910,7 +19510,7 @@ function boundedInitCheck(root, isolation) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve17(timedOut2 ? ["NOT CHECKED \u2014 init --check exceeded its 55s limit; the base is neither green nor red by this check."] : code2 === 0 ? stdout.trimEnd().split("\n") : [`NOT CHECKED \u2014 init --check could not finish: ${redact(stderr.split("\n")[0] || `exit ${code2}`)}.`]);
+      resolve18(timedOut2 ? ["NOT CHECKED \u2014 init --check exceeded its 55s limit; the base is neither green nor red by this check."] : code2 === 0 ? stdout.trimEnd().split("\n") : [`NOT CHECKED \u2014 init --check could not finish: ${redact(stderr.split("\n")[0] || `exit ${code2}`)}.`]);
     };
     child.on("error", (e) => {
       stderr += e.message;
@@ -19169,11 +19769,11 @@ demo.option("--replay <file>", "run a recorded events.jsonl session through the
     console.log(renderReplay(replay(builtInEvents, builtInContract), builtInContract));
     return;
   }
-  const file3 = resolve16(opts.replay);
+  const file3 = resolve17(opts.replay);
   if (!existsSync53(file3)) fail(`replay file not found: ${file3}`);
   try {
     const sibling = file3.replace(/\.jsonl?$/, "") + ".contract.yaml";
-    const contractFile = opts.contract ? resolve16(opts.contract) : existsSync53(sibling) ? sibling : contractPath(repoRoot());
+    const contractFile = opts.contract ? resolve17(opts.contract) : existsSync53(sibling) ? sibling : contractPath(repoRoot());
     const contract = loadContract(contractFile);
     console.log(renderReplay(replay(readFileSync59(file3, "utf-8"), contract), contract, contract ? contractFile : void 0));
   } catch (e) {
@@ -19181,10 +19781,10 @@ demo.option("--replay <file>", "run a recorded events.jsonl session through the
   }
 });
 async function demoReplayHooks(path, contractOpt) {
-  const file3 = resolve16(path);
+  const file3 = resolve17(path);
   if (!existsSync53(file3)) fail(`replay file not found: ${file3}`);
   const sibling = file3.replace(/\.jsonl?$/, "") + ".contract.yaml";
-  const contractFile = contractOpt ? resolve16(contractOpt) : existsSync53(sibling) ? sibling : null;
+  const contractFile = contractOpt ? resolve17(contractOpt) : existsSync53(sibling) ? sibling : null;
   try {
     const r = await replayHooks(readFileSync59(file3, "utf-8"), {
       contractYaml: contractFile ? readFileSync59(contractFile, "utf-8") : void 0,
@@ -19252,7 +19852,7 @@ hook.command("judge-step").description("Internal: run one model-judge step judgm
   }
 });
 hook.command("auto-finish").description("Internal, AUTO mode: verify the session's work (snapshot of the working tree if nothing was committed) and write .replume/reports/<session>.md. Started by the SessionEnd hook.").requiredOption("--session <id>", "the agent session id").option("--root <path>", "repository root (default: the current repository)").option("--limits <json>", "JSON array of 'Agent hook limits' lines for the report (Codex and Cursor)").action(async (opts) => {
-  const root = resolve16(opts.root ?? repoRoot());
+  const root = resolve17(opts.root ?? repoRoot());
   let limits;
   try {
     const parsed = opts.limits ? JSON.parse(opts.limits) : void 0;