forgedock 1.29.0 → 1.30.0

package/bin/engine/outcome-codes.mjs

@@ -48,6 +48,8 @@ export const OUTCOME_CODES = Object.freeze({
   CLI_TIMEOUT: "cli.timeout",
   CLI_SPAWN_FAILED: "cli.spawn_failed", // forge#4129: deterministic spawn failure (E2BIG, ENOENT, EACCES, ...)
   ENV_SETUP_FAILED: "env.setup_failed", // forge#4163: forge.yaml env.setup failed before the builder; an environment error, not a build failure
+  ENV_TOOL_MISSING: "env.tool_missing", // forge#4323: a validate command could not run because a host tool or module is missing; an environment error, not a conformance failure
+  ENV_REPRO_UNRUNNABLE: "env.repro_unrunnable", // forge#4334: the repro harness could not run the repro test on head; an environment error, not a conformance failure
   SANDBOX_START_FAILED: "sandbox.start_failed", // forge#4254: a lane sandbox could not start; needs-human, not relaunched
   SANDBOX_CAPACITY: "sandbox.capacity", // forge#4254: the sandbox provider had no capacity; deferred with backoff
   LEASE_HELD: "lease.held",
@@ -180,13 +182,13 @@ export function codeForTerminalReason(reason) {
  * Batch recovery classes of a lane result (forge#4267). The batch runner recovers `recoverable` rows once
  * (`orchestration.recovery.max_attempts`) and re-queues them; only `human` rows are escalations.
  */
-export const RECOVERABLE_CODES = Object.freeze([OUTCOME_CODES.CI_RED, OUTCOME_CODES.BASE_CONFLICT, OUTCOME_CODES.BUILDER_BLOCK_UNTYPED, OUTCOME_CODES.CONTRACT_INVALID]);
+export const RECOVERABLE_CODES = Object.freeze([OUTCOME_CODES.CI_RED, OUTCOME_CODES.BASE_CONFLICT, OUTCOME_CODES.BUILDER_BLOCK_UNTYPED, OUTCOME_CODES.CONTRACT_INVALID, OUTCOME_CODES.ENV_TOOL_MISSING, OUTCOME_CODES.ENV_REPRO_UNRUNNABLE]);
 /** `builder.blocked` is only reached by a typed human block: credentials, spend, promotion, customer, product-decision. */
 export const HUMAN_CODES = Object.freeze([OUTCOME_CODES.BUILDER_BLOCKED]);
 
 /**
  * `recoverable` | `human` | `terminal` for a lane result row ({outcome|terminalReason, code, issueEdited?, conflicting?}).
- * Recoverable: needs-human `ci.red`, `base.conflict`, `builder.block_untyped`, `contract.invalid` after a mid-run issue
+ * Recoverable: needs-human `ci.red`, `base.conflict`, `builder.block_untyped`, `env.tool_missing`, `env.repro_unrunnable`, `contract.invalid` after a mid-run issue
  * edit (`issueEdited`), and `ci-pending` on a conflicting PR (`conflicting`). Human: `builder.blocked`. Anything else
  * (another code, or not a needs-human/ci-pending row) is terminal. Pure, never throws.
  */

package/bin/engine/phases.mjs

@@ -349,9 +349,10 @@ export async function openDependency(issue, io) {
       return { unreadable: true, detail: `dependency #${dep} of issue ${issue} could not be read: ${e?.message || e}` };
     }
     const st = typeof d?.state === "string" ? d.state.toLowerCase() : "";
-    if (st === "open") {
-      // #4153: an open decomposed parent is a tracker; the edge resolves to its sub-issues (satisfied when all close).
-      const subs = isDecomposedRecord(d) ? await decomposedSubissues(dep, io) : null;
+    // #4153 / #4337: a decomposed parent, open or closed, is a tracker; the edge resolves to its sub-issues (satisfied
+    // when all close). No usable trail (none, untrusted, revoked, unreadable) keeps the parent itself open (fail closed).
+    if (isDecomposedRecord(d) && (st === "open" || st === "closed")) {
+      const subs = await decomposedSubissues(dep, io);
       if (!subs) { open.push(dep); continue; }
       for (const s of subs) {
         let sr;
@@ -363,6 +364,7 @@ export async function openDependency(issue, io) {
         else if (ss !== "closed") return { unreadable: true, detail: `sub-issue #${s} of decomposed dependency #${dep} has no readable state` };
       }
     }
+    else if (st === "open") open.push(dep);
     else if (st !== "closed") return { unreadable: true, detail: `dependency #${dep} of issue ${issue} has no readable state` };
   }
   return open.length ? { open: [...new Set(open)].filter((n) => n !== Number(issue)) } : null;
@@ -388,6 +390,21 @@ export async function decomposedSubissues(issue, io) {
   return subs.length ? subs : null;
 }
 
+/**
+ * #4337: reopen a CLOSED `workflow:decomposed` issue whose decomposition trusted GitHub state shows revoked
+ * (`decompositionRevoked`). `true` only when it was reopened; an open issue, no/untrusted revocation, or any read or
+ * write error is `false` (never throws), so the closed tracker keeps gating its dependents.
+ */
+export async function reopenRevokedDecomposition(issue, io) {
+  try {
+    const rec = await readIssueRecord(issue, io);
+    if (!rec || rec.empty || String(rec.state).toLowerCase() !== "closed" || !isDecomposedRecord(rec)) return false;
+    if (!(await decompositionRevoked(issue, io))) return false;
+    await io.gh(["api", "-X", "PATCH", `repos/{owner}/{repo}/issues/${issue}`, "-f", "state=open"]);
+    return true;
+  } catch { return false; }
+}
+
 /** True when a REST/`gh --json` issue record carries the `workflow:decomposed` label. */
 export const isDecomposedRecord = (rec) => (rec?.labels ?? []).some((l) => (l?.name ?? l) === "workflow:decomposed");
 

package/bin/engine-cli.mjs

@@ -166,6 +166,10 @@ export function readReproTest(cwd = process.cwd()) {
     return ["off", "prefer"].includes(v) ? v : undefined;
   } catch { return undefined; }
 }
+/** forge.yaml `decomposition.close_parent` (#3736, #4337): true closes a decomposed parent at decomposition; anything else keeps it open. */
+export function readCloseParent(cwd = process.cwd()) {
+  try { return String(parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.decomposition?.close_parent ?? "").trim() === "true"; } catch { return false; }
+}
 function readLeanSetting(key, cwd = process.cwd()) {
   try {
     const v = String(parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.engine?.[`lean_${key}`] ?? "").trim();
@@ -280,6 +284,23 @@ export function readPrecheckCommands(cwd = process.cwd()) {
   }
   return out.length ? out : undefined;
 }
+/**
+ * forge.yaml `lean.precheck.max_minutes` (#4331): the pre-PR check round budget in minutes (1..120). The one-level
+ * parser flattens a nested `precheck:` block under `lean:` to `lean.max_minutes`; flat `lean.precheck_max_minutes` also
+ * works and wins. undefined when absent, invalid or unreadable (runCore then uses verify.precheck_total_seconds, default 600 s).
+ */
+export function readPrecheckBudget(cwd = process.cwd()) {
+  try {
+    const l = parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.lean ?? {};
+    const raw = String(l.precheck_max_minutes ?? l.max_minutes ?? "").trim(), n = Number(raw);
+    return raw !== "" && Number.isFinite(n) && n >= 1 && n <= 120 ? n : undefined;
+  } catch { return undefined; }
+}
+/** runCore `precheck` option: {commands, maxMinutes} from learned.test_commands and lean.precheck.max_minutes; {} when neither is set. */
+function readPrecheckOptions(cwd = process.cwd()) {
+  const commands = readPrecheckCommands(cwd), maxMinutes = readPrecheckBudget(cwd);
+  return commands || maxMinutes ? { precheck: { ...(commands ? { commands } : {}), ...(maxMinutes ? { maxMinutes } : {}) } } : {};
+}
 /**
  * forge.yaml `env` for core lanes (#4163): `env.toolchain` ("<pm>@<x.y.z>" or "off") and `env.setup` (a command run once
  * per fresh worktree before the builder); `env.sparse_max_kb` (#4221: sparse lane checkout threshold, 0 = off). Returns runCore options; {} when absent.
@@ -637,7 +658,7 @@ export function lastLocalRun(dir) {
  */
 export async function runFromCli(argv, deps = {}) {
   const issue = parseInt(argv[0], 10);
-  if (!Number.isInteger(issue)) throw new Error("usage: forgedock run-issue <issue-number> [--lane <lane>] [--lane-override] [--path core|full] [--recover <code> [--recover-attempt n]] [--retry] [--wait-lease]");
+  if (!Number.isInteger(issue)) throw new Error("usage: forgedock run-issue <issue-number> [--lane <lane>] [--lane-override] [--path core|full] [--recover <code> [--recover-attempt n] [--recover-nonfinal]] [--retry] [--wait-lease]");
   assertOpenCodeNativeRuntime({ operation: "forgedock run-issue" });
   const lane = flag(argv, "--lane");
   if (argv.includes("--lane") && (!lane || lane.startsWith("--"))) throw new Error("--lane requires a value: staging or milestone/<slug>");
@@ -667,10 +688,11 @@ export async function runFromCli(argv, deps = {}) {
   const placementWhere = flag(argv, "--placement");
   const placement = placementWhere === "local" || placementWhere === "remote"
     ? { where: placementWhere, reason: String(flag(argv, "--placement-reason") ?? "").slice(0, 300), mode: readExecution()?.mode ?? "local" } : null;
-  // #4267: a batch recovery lane for a mechanical needs-human (`--recover <code> [--recover-attempt n]`).
+  // #4267: a batch recovery lane for a mechanical needs-human (`--recover <code> [--recover-attempt n]`); #4302: `--recover-nonfinal`
+  // marks an attempt the runner may follow with another, so the lane leaves the needs-human relabel to the runner.
   const recoverCode = flag(argv, "--recover");
   const recoverAttempt = Number(flag(argv, "--recover-attempt"));
-  const recover = recoverCode && !recoverCode.startsWith("--") ? { code: recoverCode, attempt: Number.isInteger(recoverAttempt) && recoverAttempt > 0 ? recoverAttempt : 1 } : null;
+  const recover = recoverCode && !recoverCode.startsWith("--") ? { code: recoverCode, attempt: Number.isInteger(recoverAttempt) && recoverAttempt > 0 ? recoverAttempt : 1, final: !argv.includes("--recover-nonfinal") } : null;
   const report = (r) => { if (resultFile) (deps.writeAtomic ?? writeResultAtomic)(resultFile, JSON.stringify(r) + "\n"); return r; };
   try {
     await assertRepoMatchesCwd(io, repo, { sleep: deps.sleep });
@@ -735,7 +757,7 @@ export async function runFromCli(argv, deps = {}) {
       lres = await runCore({ issue, repo: leanRepo, ...(lane ? { lane } : {}), laneOverride, branches: readBranches(), cwd: process.cwd(), dir, io: leanIo, path: enginePath, onProgress,
       onTeardown: (fn) => { teardown = fn; }, ...(env.FORGEDOCK_BATCH_ID ? { batchId: env.FORGEDOCK_BATCH_ID } : {}), ...(placement ? { placement } : {}), ...(recover ? { recover } : {}),
       emitTelemetry: deps.emitTelemetry ?? makeEmitTelemetry({ repo: leanRepo }),
-      admission: readAdmission(), heavy: readHeavy(), ...readCoreLimits(), ...readEnvConfig(), ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(readConformanceMode() ? { conformance: readConformanceMode() } : {}), ...(readContextPack() ? { contextPack: readContextPack() } : {}), ...(readReviewIncomplete() ? { reviewIncomplete: readReviewIncomplete() } : {}), ...(readReproTest() ? { reproTest: readReproTest() } : {}), ...(readReviewTrigger() ? { reviewTrigger: readReviewTrigger() } : {}), ...(readVerify() ? { verify: readVerify() } : {}), ...(readPrecheckCommands() ? { precheck: { commands: readPrecheckCommands() } } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) });
+      admission: readAdmission(), heavy: readHeavy(), ...readCoreLimits(), ...readEnvConfig(), ...(readMergeWait() ? { mergeWait: readMergeWait() } : {}), ...(readConformanceMode() ? { conformance: readConformanceMode() } : {}), ...(readContextPack() ? { contextPack: readContextPack() } : {}), ...(readReviewIncomplete() ? { reviewIncomplete: readReviewIncomplete() } : {}), ...(readReproTest() ? { reproTest: readReproTest() } : {}), ...(readCloseParent() ? { closeParent: true } : {}), ...(readReviewTrigger() ? { reviewTrigger: readReviewTrigger() } : {}), ...(readVerify() ? { verify: readVerify() } : {}), ...readPrecheckOptions(), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model") ? { reviewerModel: readLeanSetting("reviewer_model") } : {}) });
     } catch (e) { if (!interrupted) report({ terminalReason: "engine-error", detail: String(e?.message ?? e).slice(0, 500) }); throw e; }
     finally { if (!interrupted) for (const [sig, f] of Object.entries(handlers)) off(sig, f); }
     if (interrupted) return lres; // the signal handler reported and exits
@@ -1071,6 +1093,7 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
   sink.line(`batch: ${batch.id} (${batch.dir}); resume with: forgedock orchestrate --resume ${batch.id}`);
   const dir = deps.dir ?? runDir();
   const { orchestrate, formatTable, formatWaitSummary, formatSandboxSummary, formatOutcomeLists } = await import("./lean/orchestrate.mjs");
+  const { formatPrecheckSummary } = await import("./lean/precheck.mjs");
   const leanIo = deps.leanIo ?? (await import("./lean/effects.mjs")).makeLeanIo({ repo });
   const { makePrefilter, formatPrefilterSummary } = await import("./lean/prefilter.mjs");
   const prefilter = argv.includes("--no-prefilter") ? null
@@ -1091,14 +1114,14 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
     const { runCore } = deps.leanModule;
     const emitTelemetry = deps.emitTelemetry ?? makeEmitTelemetry({ repo });
     lanes = { adopt: null, runOne: (n, ln, ctx = {}) => runCore({ issue: n, repo, lane: ln, laneOverride, ...(ctx.placement ? { placement: { ...ctx.placement, mode: execMode() } } : {}), ...(ctx.recover ? { recover: ctx.recover } : {}), branches, cwd, dir, io: leanIo, agentId: `orch_${process.pid}_${n}`, emitTelemetry, batchId: batch.id,
-      admission: readAdmission(cwd), heavy: readHeavy(cwd), ...readCoreLimits(cwd), ...readEnvConfig(cwd), ...(readMergeWait(cwd) ? { mergeWait: readMergeWait(cwd) } : {}), ...(readConformanceMode(cwd) ? { conformance: readConformanceMode(cwd) } : {}), ...(readContextPack(cwd) ? { contextPack: readContextPack(cwd) } : {}), ...(readReviewIncomplete(cwd) ? { reviewIncomplete: readReviewIncomplete(cwd) } : {}), ...(readReproTest(cwd) ? { reproTest: readReproTest(cwd) } : {}), ...(readReviewTrigger(cwd) ? { reviewTrigger: readReviewTrigger(cwd) } : {}), ...(readVerify(cwd) ? { verify: readVerify(cwd) } : {}), ...(readPrecheckCommands(cwd) ? { precheck: { commands: readPrecheckCommands(cwd) } } : {}), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model", cwd) ? { reviewerModel: readLeanSetting("reviewer_model", cwd) } : {}) }) };
+      admission: readAdmission(cwd), heavy: readHeavy(cwd), ...readCoreLimits(cwd), ...readEnvConfig(cwd), ...(readMergeWait(cwd) ? { mergeWait: readMergeWait(cwd) } : {}), ...(readConformanceMode(cwd) ? { conformance: readConformanceMode(cwd) } : {}), ...(readContextPack(cwd) ? { contextPack: readContextPack(cwd) } : {}), ...(readReviewIncomplete(cwd) ? { reviewIncomplete: readReviewIncomplete(cwd) } : {}), ...(readReproTest(cwd) ? { reproTest: readReproTest(cwd) } : {}), ...(readCloseParent(cwd) ? { closeParent: true } : {}), ...(readReviewTrigger(cwd) ? { reviewTrigger: readReviewTrigger(cwd) } : {}), ...(readVerify(cwd) ? { verify: readVerify(cwd) } : {}), ...readPrecheckOptions(cwd), ...(model ? { builderModel: model } : {}), ...(readLeanSetting("reviewer_model", cwd) ? { reviewerModel: readLeanSetting("reviewer_model", cwd) } : {}) }) };
   } else {
     const laneScript = deps.laneScript ?? fileURLToPath(new URL("./forgedock.mjs", import.meta.url));
     // #4256: the placement orchestrate decided for a lane (ctx.placement) reaches it as --placement/--placement-reason.
     // #4267: a recovery lane (ctx.recover) reaches it as --recover/--recover-attempt.
     const placementOf = new Map(), recoverOf = new Map();
     const laneArgs = (n, ln) => { const pl = placementOf.get(n), rc = recoverOf.get(n); return ["--repo", repo, ...(ln ? ["--lane", ln] : []), ...(laneOverride ? ["--lane-override"] : []), ...(model ? ["--model", model] : []),
-      ...(pl ? ["--placement", pl.where, "--placement-reason", pl.reason ?? ""] : []), ...(rc ? ["--recover", rc.code, "--recover-attempt", String(rc.attempt ?? 1)] : [])]; };
+      ...(pl ? ["--placement", pl.where, "--placement-reason", pl.reason ?? ""] : []), ...(rc ? ["--recover", rc.code, "--recover-attempt", String(rc.attempt ?? 1), ...(rc.final === false ? ["--recover-nonfinal"] : [])] : [])]; };
     const withPlacement = (l) => ({ runOne: (n, ln, ctx = {}) => {
       if (ctx.placement) placementOf.set(n, ctx.placement); else placementOf.delete(n);
       if (ctx.recover) recoverOf.set(n, ctx.recover); else recoverOf.delete(n);
@@ -1153,6 +1176,9 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
     }
   }
   const orch = deps.orchestration ?? readOrchestration(cwd);
+  // #4304: recovery lanes run on the core path only (run-issue throws on --recover with full), so a full-path repo gets none.
+  const recoveryOn = Boolean(orch.recovery?.maxAttempts) && (deps.enginePath !== undefined ? deps.enginePath : readEnginePath(cwd)) !== "full";
+  if (orch.recovery?.maxAttempts && !recoveryOn) sink.line("recovery: off (engine.path is full; recovery lanes run on the core path only)");
   // #4190: usage-limit holds live in the host store keyed by the account the next lane would use.
   const limitsMod = await import("./lean/limits.mjs");
   const limits = deps.limits ?? limitsMod.openLimits(limitsMod.limitsFile(env));
@@ -1224,38 +1250,50 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
     } catch { near = false; }
     if (near) await runGcPhase("admission");
   };
-  const rows = await orchestrate({
-    beforeAdmit,
-    issues, parallel, prefilter, resolveLane: laneOf, store: batch.store, getParallel: batch.readParallel, ...lanes,
-    breaker: orch.breaker, maxDeferrals: orch.maxDeferrals, ...(deps.pollMs ? { pollMs: deps.pollMs } : {}), ...budget, limits, identity, batchId: batch.id, drift,
-    ...(registry ? { sched: { registry, batch: batch.id, repo, cap: orch.globalParallel ?? null }, priorityOf: async (n) => schedMod.priorityFromLabels(await labelNames(n)) } : {}),
-    ...(remote ? { remote } : {}),
-    // #4267: mechanical needs-human outcomes are recovered in the batch; every runner decision is a FORGE:DECISION.
-    ...(orch.recovery?.maxAttempts ? { recovery: orch.recovery } : {}),
-    decide: deps.decide ?? (async (d) => {
-      if (d?.issue == null) { sink.line(`decision: ${d?.what} (why: ${d?.why}; alternative: ${d?.alternative})`); return; }
-      const body = `<!-- FORGE:DECISION -->\n## Decision (batch ${batch.id})\n**What**: ${d.what}\n**Why**: ${d.why}\n**Alternative**: ${d.alternative}`;
-      try { await leanIo.gh(["issue", "comment", String(d.issue), "-R", repo, "--body", body]); } catch { /* best effort: the batch log keeps the row */ }
-    }),
-    // A recovery that ended for good without the lane relabelling it (engine-error, deferred): needs-human back, one comment.
-    relabelNeedsHuman: deps.relabelNeedsHuman ?? (async ({ issue, evidence }) => {
-      try {
-        await leanIo.gh(["issue", "comment", String(issue), "-R", repo, "--body", `<!-- FORGE:NEEDS_HUMAN -->\n## Needs human\n${evidence}`]);
-        await leanIo.gh(["issue", "edit", String(issue), "-R", repo, "--add-label", "needs-human"]);
-      } catch { /* best effort: the batch row keeps the evidence */ }
-    }),
-    conflicting: deps.conflicting ?? (async (_n, pr) => {
-      try { return JSON.parse(await leanIo.gh(["pr", "view", String(pr), "-R", repo, "--json", "mergeable"]))?.mergeable === "CONFLICTING"; } catch { return false; }
-    }),
-    onCrossLane: (e) => {
-      crossLane.push(e);
-      sink.line(`cross-lane: #${e.issue} (${e.lane}) depends on #${e.dependency} (${e.dependencyLane}); its fix will not be on ${e.lane}: re-milestone #${e.dependency} or wait for a milestone sync`);
-    },
-    readBody: maint || registry || hybrid
-      ? async (n) => { const v = JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body,labels"])); labelsOf.set(n, (v.labels ?? []).map((x) => x.name)); return v.body; }
-      : async (n) => JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body"])).body,
-    onUpdate: (r) => sink.row(r),
-  });
+  // #4318: SIGINT/SIGTERM of a foreground dispatcher run the batch-exit relabel, then exit 128+signo (the lane pattern above).
+  let exitRelabel = null, interrupted = false;
+  const on = deps.processOn ?? ((s, f) => process.on(s, f)), off = deps.processOff ?? ((s, f) => process.removeListener(s, f));
+  const exitProc = deps.exit ?? ((c) => process.exit(c));
+  const SIGNO = { SIGINT: 2, SIGTERM: 15 };
+  const handlers = daemon ? {} : Object.fromEntries(Object.keys(SIGNO).map((sig) => [sig, async () => {
+    if (interrupted) return;
+    interrupted = true;
+    try { if (exitRelabel) await exitRelabel(`interrupted by ${sig}`); } catch { /* exit anyway */ }
+    exitProc(128 + SIGNO[sig]);
+  }]));
+  for (const [sig, f] of Object.entries(handlers)) on(sig, f);
+  let rows;
+  try {
+    rows = await orchestrate({
+      beforeAdmit,
+      issues, parallel, prefilter, resolveLane: laneOf, store: batch.store, getParallel: batch.readParallel, ...lanes,
+      breaker: orch.breaker, maxDeferrals: orch.maxDeferrals, ...(deps.pollMs ? { pollMs: deps.pollMs } : {}), ...budget, limits, identity, batchId: batch.id, drift,
+      ...(registry ? { sched: { registry, batch: batch.id, repo, cap: orch.globalParallel ?? null }, priorityOf: async (n) => schedMod.priorityFromLabels(await labelNames(n)) } : {}),
+      ...(remote ? { remote } : {}),
+      // #4267: mechanical needs-human outcomes are recovered in the batch; every runner decision is a FORGE:DECISION.
+      ...(recoveryOn ? { recovery: orch.recovery } : {}),
+      decide: deps.decide ?? (async (d) => {
+        if (d?.issue == null) { sink.line(`decision: ${d?.what} (why: ${d?.why}; alternative: ${d?.alternative})`); return; }
+        const body = `<!-- FORGE:DECISION -->\n## Decision (batch ${batch.id})\n**What**: ${d.what}\n**Why**: ${d.why}\n**Alternative**: ${d.alternative}`;
+        try { await leanIo.gh(["issue", "comment", String(d.issue), "-R", repo, "--body", body]); } catch { /* best effort: the batch log keeps the row */ }
+      }),
+      // A recovery that ended for good without the lane relabelling it (engine-error, deferred): needs-human back, one comment.
+      relabelNeedsHuman: deps.relabelNeedsHuman ?? makeRelabelNeedsHuman({ gh: (a) => leanIo.gh(a), repo }),
+      // #4318: a dispatcher signal relabels the queued recoveries before it exits (the daemon resumes its batches instead)
+      ...(daemon ? {} : { onExit: (fn) => { exitRelabel = fn; } }),
+      conflicting: deps.conflicting ?? (async (_n, pr) => {
+        try { return JSON.parse(await leanIo.gh(["pr", "view", String(pr), "-R", repo, "--json", "mergeable"]))?.mergeable === "CONFLICTING"; } catch { return false; }
+      }),
+      onCrossLane: (e) => {
+        crossLane.push(e);
+        sink.line(`cross-lane: #${e.issue} (${e.lane}) depends on #${e.dependency} (${e.dependencyLane}); its fix will not be on ${e.lane}: re-milestone #${e.dependency} or wait for a milestone sync`);
+      },
+      readBody: maint || registry || hybrid
+        ? async (n) => { const v = JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body,labels"])); labelsOf.set(n, (v.labels ?? []).map((x) => x.name)); return v.body; }
+        : async (n) => JSON.parse(await leanIo.gh(["issue", "view", String(n), "-R", repo, "--json", "body"])).body,
+      onUpdate: (r) => sink.row(r),
+    });
+  } finally { for (const [sig, f] of Object.entries(handlers)) off(sig, f); }
   const report = ["\n" + formatTable(rows), ...formatOutcomeLists(rows)];
   const pfLine = formatPrefilterSummary(rows);
   if (pfLine) report.push(pfLine);
@@ -1263,6 +1301,8 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
   try { heavyStats = deps.heavyStats !== undefined ? deps.heavyStats : (await import("./lean/heavy.mjs")).openHeavy(schedMod.schedDir()).stats(); } catch { heavyStats = null; }
   const waitLine = formatWaitSummary(rows, heavyStats);
   if (waitLine) report.push(waitLine);
+  const precheckLine = formatPrecheckSummary(rows); // #4331
+  if (precheckLine) report.push(precheckLine);
   let day = null;
   try { day = execBudget ? execBudget.dayTotals() : null; } catch { day = null; }
   const sbxLine = formatSandboxSummary(rows, { budget: execConf?.budget ?? null, day });
@@ -1276,6 +1316,30 @@ export async function runBatch({ argv, cwd: callerCwd = process.cwd(), env: call
   return { rows, crossLane, batch: batch.id, reclaimed, ok };
 }
 
+/**
+ * #4318: the batch runner's needs-human relabel. Re-reads the issue first: closed, or a live FORGE:STATE lease (the runner
+ * never holds one, so it is another actor's) → "skipped". Label first: a failed label add → "failed" with no comment (a
+ * resume retries); then the capped FORGE:NEEDS_HUMAN comment, whose failure keeps the label → true.
+ */
+export function makeRelabelNeedsHuman({ gh, repo, now = () => Date.now() }) {
+  return async ({ issue, evidence }) => {
+    const { stateOf } = await import("./lean/context.mjs");
+    try {
+      const v = JSON.parse(await gh(["issue", "view", String(issue), "-R", repo, "--json", "state,body"]));
+      if (String(v?.state ?? "").toUpperCase() === "CLOSED") return "skipped";
+      const lease = stateOf(v?.body)?.lease;
+      if (lease && Number(lease.until) > now()) return "skipped";
+    } catch { /* unreadable: relabel as before */ }
+    try { await gh(["issue", "edit", String(issue), "-R", repo, "--add-label", "needs-human"]); } catch { return "failed"; }
+    try {
+      // #4315: the evidence carries the full lane reason; capped so it never exceeds GitHub's comment limit
+      const { capComment } = await import("./lean/render.mjs");
+      await gh(["issue", "comment", String(issue), "-R", repo, "--body", capComment(`<!-- FORGE:NEEDS_HUMAN -->\n## Needs human\n${evidence}`)]);
+    } catch { /* best effort: the label is on, the batch row keeps the evidence */ }
+    return true;
+  };
+}
+
 /** The batch report's "reclaimed" line (#4183). */
 export function formatReclaimed(r) {
   if (!r?.enabled) return "reclaimed: off (hygiene.auto_gc: false)";

package/bin/engine.mjs

@@ -9,7 +9,7 @@ import { execFileSync } from "node:child_process";
 import { createHash, scryptSync } from "node:crypto";
 import { hostname as osHostname, homedir } from "node:os";
 import { appendEvent, readLog, deriveState, rewriteLog, scopeEvents } from "./engine/runlog.mjs";
-import { pickPhase, TERMINAL_REASONS, issueSnapshot, hasInvestigationExit, postCycleMarker, nextCycleNumber, newestCycle, cycleResetProvable, remediationHeadStale, decompositionRevoked, openDependency } from "./engine/phases.mjs";
+import { pickPhase, TERMINAL_REASONS, issueSnapshot, hasInvestigationExit, postCycleMarker, nextCycleNumber, newestCycle, cycleResetProvable, remediationHeadStale, decompositionRevoked, openDependency, reopenRevokedDecomposition } from "./engine/phases.mjs";
 import { reconcileState } from "./engine/reconcile.mjs";
 import { makeProjector } from "./engine/projector.mjs";
 import { VALID_BACKENDS, resolveRunTmpRoot, runTmpDir } from "./runner.mjs";
@@ -570,6 +570,8 @@ export async function runIssue(opts) {
     // revocation alone suffices now that the size gate is gone. Anything else keeps the terminal; an
     // unreadable comment trail fails closed.
     if (state.terminalReason === "decomposed" && await decompositionRevoked(issue, io)) {
+      // #4337: a parent closed at decomposition is reopened on GitHub too, or the pre-phase divergence check ends it invalid.
+      await reopenRevokedDecomposition(issue, io);
       reopenUncommit = ["build", "decompose"];
     } else if (state.terminalReason !== "engine-error" && state.terminalReason !== "phase-complete" &&
         state.terminalReason !== "needs-human") {

package/bin/lean/batch.test.mjs

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import { tmpDir } from "../tests/_tmp.mjs";
 import { orchestrate, deferPolicy, DEFER_BACKOFF_S } from "./orchestrate.mjs";
 import { openBatch, fsTypeOf, assertDiskPath, isLaneAlive, writeAtomic, launchLane } from "./batch.mjs";
-import { orchestrateFromCli, runFromCli, readOrchestration } from "../engine-cli.mjs";
+import { orchestrateFromCli, runFromCli, readOrchestration, makeRelabelNeedsHuman } from "../engine-cli.mjs";
 
 // orchestrateFromCli opens the host lane registry (#4191): keep it in a temp dir, also for spawned dispatchers.
 process.env.FORGEDOCK_SCHED_DIR = tmpDir("batch-sched-");
@@ -232,3 +232,64 @@ describe("lane launch env (#4179)", () => {
     assert.deepEqual(spawned[0].argv, ["/x/forgedock.mjs", "run-issue", "7", "--repo", "o/r", "--result-file", batch.resultFile(7)]);
   });
 });
+
+describe("#4318: the batch dispatcher's signal relabel and the needs-human relabel hook", () => {
+  it("SIGINT of a foreground dispatcher relabels a queued recovery with the signal as cause, then exits 130; handlers are removed", async () => {
+    const leanIo = {
+      gh: async (a) => (a.includes("milestone") ? JSON.stringify({ milestone: null }) : JSON.stringify({ body: "" })),
+      git: async (a) => (a[0] === "ls-remote" ? "abc\trefs/heads/staging\n" : ""),
+    };
+    const handlers = new Map(), removed = [], exits = [], relabels = [];
+    const l = console.log;
+    console.log = () => {};
+    try {
+      await orchestrateFromCli(["1", "2", "--parallel", "1", "--repo", "o/r", "--no-prefilter"], { dir: tmpDir("sig-"), batchRoot: tmpDir("sig-batch-"), allowTmpfs: true,
+        emitTelemetry: async () => {}, io: { gh: async () => "o/r\n" }, leanIo, sched: null, decide: () => {},
+        orchestration: { breaker: null, maxDeferrals: 3, globalParallel: null, recovery: { maxAttempts: 2 } },
+        processOn: (s, f) => handlers.set(s, f), processOff: (s, f) => { if (handlers.get(s) === f) removed.push(s); }, exit: (c) => exits.push(c),
+        relabelNeedsHuman: async (x) => { relabels.push(x); return true; },
+        leanModule: { runCore: async (o) => {
+          if (o.issue === 1 && !o.recover) return { terminalReason: "needs-human", code: "ci.red", detail: "Required check(s) failed on PR #55: test" };
+          if (o.issue === 2) await handlers.get("SIGINT")(); // issue 1's attempt is queued behind issue 2 (K=1)
+          return { terminalReason: "merged", pr: 50 + o.issue };
+        } } });
+    } finally { console.log = l; }
+    assert.deepEqual(exits, [130]);
+    assert.equal(relabels.length, 1); assert.equal(relabels[0].issue, 1);
+    assert.match(relabels[0].evidence, /the batch stopped \(interrupted by SIGINT\)/);
+    assert.deepEqual(removed.sort(), ["SIGINT", "SIGTERM"]);
+  });
+
+  describe("makeRelabelNeedsHuman", () => {
+    const LIVE = (until) => `body\n<!-- FORGE:STATE\n${JSON.stringify({ v: 1, issue: 7, lease: { by: "core_1", until, host: "h", pid: 1 } })}\n-->`;
+    const hook = (view, fail = {}) => {
+      const calls = [];
+      const gh = async (a) => {
+        calls.push(a[1]);
+        if (a[1] === "view") return JSON.stringify(view);
+        if (fail[a[1]]) throw new Error(`${a[1]} failed`);
+        return "";
+      };
+      return { calls, run: () => makeRelabelNeedsHuman({ gh, repo: "o/r", now: () => 1000 })({ issue: 7, evidence: "why" }) };
+    };
+    it("a closed issue or a live lease is skipped without a write", async () => {
+      for (const view of [{ state: "CLOSED", body: "" }, { state: "OPEN", body: LIVE(5000) }]) {
+        const h = hook(view);
+        assert.equal(await h.run(), "skipped");
+        assert.deepEqual(h.calls, ["view"]);
+      }
+    });
+    it("an expired lease relabels: the label first, then the comment", async () => {
+      const h = hook({ state: "OPEN", body: LIVE(500) });
+      assert.equal(await h.run(), true);
+      assert.deepEqual(h.calls, ["view", "edit", "comment"]);
+    });
+    it("a failed label add posts no comment and reports failed; a failed comment keeps the label", async () => {
+      const a = hook({ state: "OPEN", body: "" }, { edit: true });
+      assert.equal(await a.run(), "failed");
+      assert.deepEqual(a.calls, ["view", "edit"]);
+      const b = hook({ state: "OPEN", body: "" }, { comment: true });
+      assert.equal(await b.run(), true);
+    });
+  });
+});

package/bin/lean/conformance.mjs

@@ -18,8 +18,8 @@ export const DECISION_SOURCES = Object.freeze(["doc", "lint", "precedent", "spec
 const REQ_STATUS = ["implemented", "partial", "missing", "deferred", "post-deploy", "not-applicable"];
 const COVER_STATUS = ["covered", "narrowed", "missing"];
 const PRESERVE_STATUS = ["intact", "violated", "unverified"];
-/** The first path:line anywhere in the evidence text (backticks, quotes and brackets around it are ignored). */
-const EVIDENCE_RE = /([^\s:`'"()[\]<>,;]+):(\d+)/;
+/** A path:line inside one evidence token; the path may hold ( ) [ ] segments (route groups, [slug], [...slug]) (#4327). */
+const EVIDENCE_RE = /([^:]+):(\d+)/;
 /** Test files in any common ecosystem: test dirs, *.test.* / *.spec.*, test_*.*, *_test.*, *Test(s).java|kt|cs|php|scala, *_spec.rb, tests.rs, conftest.py, snapshots. */
 const TEST_RE = /(^|\/)(test|tests|__tests__|spec|specs|testdata|__snapshots__)\/|\.(test|spec)\.[a-z0-9]+$|(^|\/)test_[^/]+\.[a-z0-9]+$|_test\.[a-z0-9]+$|Tests?\.(java|kt|kts|cs|php|scala|swift)$|_spec\.rb$|(^|\/)tests\.rs$|(^|\/)conftest\.py$|\.bats$|\.snap$/;
 /** Files any change may touch without being a deliverable: changelogs and dependency lockfiles. */
@@ -112,6 +112,42 @@ export function movingBaseDiff(command) {
   return null;
 }
 
+/** Option names whose value a tool writes (output, report, cache or temp dirs), not reads (#4325). */
+const WRITE_OPT = /^-(?:o|O|-?[\w-]*(?:out|dir|temp|tmp|cache|report|junit|xml|log)[\w-]*)$/i;
+const TMP_PATH = /\$(?:\{TMPDIR(?::-[^}]*)?\}|TMPDIR)\/([^\s"'`;|&<>()=]+)/g;
+/**
+ * #4325: the `$TMPDIR/<name>` paths a frozen command reads without creating them itself. The run TMPDIR is per run, so such
+ * a file (written by the builder before) is gone for the engine's red-green check and for any rerun. A path counts as
+ * created when it, or a directory above it, was earlier the target of `>`/`>>`, `tee`, `touch|mkdir|mktemp`, the last
+ * argument of `cp|mv|ln|install`, an output-like option (`-o`, `--output`, `--basetemp`, `--junitxml`, `--cache-dir`…) or an
+ * env assignment (`X=$TMPDIR/y`). Returns the read paths in first-use order (deduped), e.g. ["$TMPDIR/req.txt"].
+ */
+export function tmpdirInputs(command) {
+  const made = [], reads = [];
+  const createdAbove = (p) => made.some((m) => p === m || p.startsWith(`${m}/`));
+  for (const seg of String(command ?? "").split(/&&|\|\||;|\||\n/)) {
+    const toks = seg.trim().split(/\s+/).filter(Boolean).map((t) => t.replace(/^["']+|["']+$/g, ""));
+    const words = toks.filter((t) => !/^[A-Za-z_]\w*=/.test(t));
+    const cmd = (words[0] ?? "").replace(/^.*\//, "");
+    toks.forEach((tok, i) => {
+      for (const m of tok.matchAll(TMP_PATH)) {
+        const path = m[1].replace(/\/+$/, "");
+        const before = tok.slice(0, m.index), prev = toks[i - 1] ?? "";
+        const opt = /^(-[\w-]+)=["']?$/.exec(before)?.[1] ?? (before === "" && /^-/.test(prev) ? prev : null);
+        const write = /\d*>>?$|&>$/.test(before) || (before === "" && /^(?:\d*>>?|&>)$/.test(prev))
+          || /^[A-Za-z_]\w*=["']?$/.test(before) || (opt !== null && WRITE_OPT.test(opt))
+          || cmd === "tee" || ["touch", "mkdir", "mktemp"].includes(cmd)
+          || (["cp", "mv", "ln", "install"].includes(cmd) && i === toks.length - 1);
+        if (write) made.push(path);
+        else if (!createdAbove(path) && !reads.includes(`$TMPDIR/${path}`)) reads.push(`$TMPDIR/${path}`);
+      }
+    });
+  }
+  return reads;
+}
+
+const tmpInputProblem = (id, p) => `${id}: reads ${p}, which the command does not create; the run TMPDIR is per run, so the engine's rerun and red-green check will not find it. Create the file inside the command (\`… > ${p} && …\`) or use a path the repo tracks`;
+
 export function validateContract(c, issueText, { repro = false } = {}) {
   const problems = [];
   if (!c || typeof c !== "object" || Array.isArray(c)) return { ok: false, problems: ["contract.json is missing or not a JSON object"] };
@@ -142,11 +178,13 @@ export function validateContract(c, issueText, { repro = false } = {}) {
     if (!v?.id || blank(v?.command)) { problems.push("validate entry without id or command"); continue; }
     const ref = movingBaseDiff(v.command);
     if (ref) problems.push(`${v.id}: \`git diff\` against the moving ${ref} tip fails as soon as the base moves on, even when the change is fine; compare against the merge base instead (\`${ref}...HEAD\` or \`$(git merge-base HEAD ${ref})\`)`);
+    for (const p of tmpdirInputs(v.command)) problems.push(tmpInputProblem(v.id, p));
   }
   if (repro) {
     const t = c.repro_test;
     if (t === "none") { if (blank(c.repro_test_reason)) problems.push(`repro_test "none" needs a one-line repro_test_reason`); }
     else if (!t || typeof t !== "object" || Array.isArray(t) || blank(t.path) || blank(t.command)) problems.push(`this is a bug: repro_test must be {"path","id","command"} (a test that fails on the base and passes after the fix) or "none" with a repro_test_reason`);
+    else for (const p of tmpdirInputs(t.command)) problems.push(tmpInputProblem("repro_test", p));
   }
   if (JSON.stringify(c).length > MAX_CONTRACT_CHARS) problems.push(`the contract is over ${MAX_CONTRACT_CHARS} characters; keep quotes to the requirement sentence and descriptions short`);
   return { ok: problems.length === 0, problems };
@@ -187,14 +225,51 @@ export function applyAmendments(frozen, amendments, issueText = null) {
   return { contract: c, applied, toTrack, problems };
 }
 
+const PY_MISSING_RE = /ModuleNotFoundError: No module named '([^']+)'|ImportError: No module named '?([\w.]+)'?/;
+const NODE_MISSING_RE = /Cannot find (?:module|package) '([^']+)'/;
+const CMD_NOT_FOUND_RE = /([^\s:'"`]+): command not found/, SH_NOT_FOUND_RE = /([^\s:'"`]+): not found\b/;
+const KIND_NAME = { command: "command", "python-module": "Python module", "node-module": "Node package" };
+/**
+ * forge#4323: the host tool or module a failed command could not find, from its {rc, output}: bash/sh "X: command not found"
+ * (or rc 127), python "No module named x" (top-level package), node "Cannot find module|package 'x'" (bare specifiers only).
+ * Returns {tool, kind: command|python-module|node-module} or null. A path, a relative specifier or a name the repo tracks
+ * (`repoHas(name)`) is null: a module the change forgot to create is a code defect, not the environment.
+ */
+export function missingTool({ rc, output } = {}, { repoHas = () => false, command = "" } = {}) {
+  const out = String(output ?? "");
+  const local = (name) => !name || name.startsWith(".") || name.startsWith("/") || name.startsWith("file:") || repoHas(name);
+  const py = PY_MISSING_RE.exec(out);
+  if (py) { const tool = String(py[1] ?? py[2]).split(".")[0]; return local(tool) ? null : { tool, kind: "python-module" }; }
+  const js = NODE_MISSING_RE.exec(out);
+  if (js) {
+    const spec = js[1], scoped = spec.startsWith("@");
+    if (!scoped && spec.includes("/")) return null;
+    const tool = scoped ? spec.split("/").slice(0, 2).join("/") : spec;
+    return local(tool) || (scoped && !tool.includes("/")) ? null : { tool, kind: "node-module" };
+  }
+  const cmd = CMD_NOT_FOUND_RE.exec(out)?.[1] ?? (rc === 127 ? SH_NOT_FOUND_RE.exec(out)?.[1] ?? String(command).trim().split(/\s+/)[0] : null);
+  if (!cmd || cmd.includes("/") || local(cmd)) return null;
+  return { tool: cmd, kind: "command" };
+}
+
+/** `repoHas` for missingTool: true when any tracked path has a segment equal to `name` or `name.py`. */
+export function repoTracks(paths) {
+  const segs = new Set();
+  for (const p of paths ?? []) for (const x of String(p).split("/")) segs.add(x);
+  return (name) => segs.has(name) || segs.has(`${name}.py`);
+}
+
 /**
  * Deterministic checks before any reviewer tokens are spent: unauthorized files, failed or missing validation,
  * requirements not implemented, deferrals without a tracking issue, and unexempted hotspot growth. Returns {ok, failures[]}; each failure carries a
- * `kind` (scope_creep, validate_missing, validate_failed, requirement_unimplemented, untracked_deferral, hotspot_growth, repro_red_green) so callers can
+ * `kind` (scope_creep, validate_missing, validate_failed, validate_env, requirement_unimplemented, untracked_deferral, hotspot_growth, repro_red_green, repro_env) so callers can
  * tell the builder's own failed checks apart from bookkeeping gaps. `ciVerified` (#4167): the current head passed the
  * engine's CI verification, so a validate id left to CI is not missing; a recorded non-zero exit still fails. `repro` (#4271): the repro_test red-green words, checked when given.
+ * `validateRuns` (#4323): the engine's rerun {[id]: {rc, output}} of validate commands recorded as failed. A rerun that passes
+ * counts as passed; one that could not find a host tool or module (missingTool, with `repoHas`) is kind validate_env, code
+ * env.tool_missing (skipped on a CI-verified head), not a conformance failure.
  */
-export function precheck({ contract, result, changedFiles, ignore = [], ciVerified = false, hotspots = null, repro = null }) {
+export function precheck({ contract, result, changedFiles, ignore = [], ciVerified = false, hotspots = null, repro = null, validateRuns = null, repoHas = () => false }) {
   const failures = [];
   const creep = changedFiles.filter((f) => !ignore.some((p) => f.startsWith(p)) && !authorizationOf(contract, f));
   if (creep.length) failures.push({ code: C.CONFORMANCE_SCOPE_CREEP, kind: "scope_creep", detail: `changed outside the contract's deliverables: ${creep.join(", ")}` });
@@ -205,7 +280,14 @@ export function precheck({ contract, result, changedFiles, ignore = [], ciVerifi
     const leftToCi = !r || (r.ci === true && r.exit === undefined);
     if (ciVerified && leftToCi) continue;
     if (leftToCi) failures.push({ code: C.CONFORMANCE_UNIMPLEMENTED, kind: "validate_missing", detail: `validate ${v.id} (\`${v.command}\`) has no recorded result` });
-    else if (r.exit !== 0) failures.push({ code: C.CONFORMANCE_UNIMPLEMENTED, kind: "validate_failed", detail: `validate ${v.id} (\`${v.command}\`) failed (exit ${r.exit})` });
+    else if (r.exit !== 0) {
+      const rerun = validateRuns?.[v.id];
+      if (rerun?.rc === 0) continue;
+      const miss = rerun ? missingTool(rerun, { repoHas, command: v.command }) : null;
+      if (miss && ciVerified) continue;
+      if (miss) failures.push({ code: C.ENV_TOOL_MISSING, kind: "validate_env", tool: miss.tool, detail: `validate ${v.id} (\`${v.command}\`) could not run: the host is missing ${KIND_NAME[miss.kind]} '${miss.tool}' (environment, not the change)` });
+      else failures.push({ code: C.CONFORMANCE_UNIMPLEMENTED, kind: "validate_failed", detail: `validate ${v.id} (\`${v.command}\`) failed (exit ${r.exit})` });
+    }
   }
   const st = Array.isArray(result?.requirements) ? result.requirements : [];
   for (const r of contract.requirements ?? []) {
@@ -224,13 +306,20 @@ export function precheck({ contract, result, changedFiles, ignore = [], ciVerifi
 /**
  * #4271: the frozen repro_test's red-green proof ({base, head} words from scripts/acceptance-red-green.sh). Anything but
  * HEAD=RAN BASE=FAILED fails; code conformance.unimplemented, so it blocks in shadow too and goes back to the builder.
+ * #4334: HEAD=UNRUNNABLE or no words (the harness could not run the test) is env.repro_unrunnable, kind repro_env: an
+ * environment error, never a builder resume.
  */
 export function reproFailures(contract, { base, head } = {}) {
   if (head === "RAN" && base === "FAILED") return [];
   const t = contract?.repro_test ?? {};
   const name = [t.path, t.id].filter((x) => !blank(x)).join(" ") || "repro_test";
+  if (!head || head === "UNRUNNABLE") {
+    return [{ code: C.ENV_REPRO_UNRUNNABLE, kind: "repro_env",
+      detail: `repro test ${name} (\`${t.command ?? ""}\`): the harness could not run the test on head (environment, not the change); got BASE=${base ?? "UNRUNNABLE"} HEAD=${head ?? "UNRUNNABLE"}` }];
+  }
+  const skipped = base === "SKIPPED" ? " (base not run: head did not pass)" : "";
   return [{ code: C.CONFORMANCE_UNIMPLEMENTED, kind: "repro_red_green",
-    detail: `repro test ${name} (\`${t.command ?? ""}\`) must fail on the base and pass on head; got BASE=${base ?? "UNRUNNABLE"} HEAD=${head ?? "UNRUNNABLE"}` }];
+    detail: `repro test ${name} (\`${t.command ?? ""}\`) must fail on the base and pass on head; got BASE=${base ?? "UNRUNNABLE"} HEAD=${head}${skipped}` }];
 }
 
 const EXEMPT_RE = /hotspot-exempt:\s*\S/i;
@@ -288,10 +377,42 @@ export function resolveEvidencePath(p, changedFiles = []) {
   const n = normalizeEvidencePath(p, { changedFiles });
   return n && changedFiles.includes(n) ? n : null;
 }
+const count = (s, ch) => s.split(ch).length - 1;
+/** Drops a leading or trailing bracket that has no partner inside the path: `(src/a.js` -> `src/a.js`, `(g)/a.tsx` stays. */
+function trimUnbalanced(p) {
+  for (let again = true; again && p;) {
+    again = false;
+    for (const [o, c] of [["(", ")"], ["[", "]"]]) {
+      if (p.startsWith(o) && count(p, o) > count(p, c)) { p = p.slice(1); again = true; }
+      if (p.endsWith(c) && count(p, c) > count(p, o)) { p = p.slice(0, -1); again = true; }
+    }
+  }
+  return p;
+}
+/**
+ * The first path:line anywhere in the evidence text, verbatim (#4327: `(group)`, `[slug]`, `[...slug]` segments kept).
+ * Backticks and quotes are ignored, a markdown link `[label](path:line)` yields its target, and only brackets with no
+ * partner inside the path (prose like `(src/a.js:3)`) are dropped.
+ */
+export function evidencePathLine(text) {
+  for (let tok of String(text ?? "").replace(/[`'"]/g, "").split(/[\s,;<>]+/)) {
+    const link = tok.lastIndexOf("](");
+    if (link >= 0) tok = tok.slice(link + 2);
+    const m = EVIDENCE_RE.exec(tok);
+    const path = m && trimUnbalanced(m[1]);
+    if (path) return { path, line: m[2] };
+  }
+  return null;
+}
 /** The path:line in an evidence string, with the path normalized; null when there is none. */
 function evidenceOf(text, ctx) {
-  const m = EVIDENCE_RE.exec(String(text ?? ""));
-  return m ? { path: normalizeEvidencePath(m[1], ctx), line: m[2] } : null;
+  const m = evidencePathLine(text);
+  return m ? { path: normalizeEvidencePath(m.path, ctx), line: m.line } : null;
+}
+const MISSING_PATH_RE = /^[^:]+: evidence path .+ does not exist$/;
+/** #4327: true when every problem of an incomplete review is an evidence path that did not resolve (a re-ask can fix it). */
+export function evidencePathOnly(problems = []) {
+  return problems.length > 0 && problems.every((p) => MISSING_PATH_RE.test(String(p)));
 }
 const reviewedFiles = (changedFiles, ignore) => changedFiles.filter((x) => !ignore.some((pre) => x.startsWith(pre)));