@@ -247,6 +247,8 @@ Before resuming, the command streams failed-job console output and compares
 failure diagnostics with the PR's changed files. When recovering through resume
 ancestry, it checks the latest run and every ancestor visited. It refuses to resume
 if a failed test or a file referenced in a failure diagnostic is changed by the PR.
+The refusal includes the first matching filename, failure excerpt, and console
+log URL. Large excerpts are truncated with an explicit marker.
 Logs are scanned one at a time with bounded memory. HTTP compression is decoded as the
 response arrives. A match cancels the download and skips remaining logs. Unknown
 or unavailable failure details do not prevent resuming; the check uses the
 
@@ -14,6 +14,25 @@ const infrastructure = createMatcher(FAILURE_PATTERNS.infrastructure);
 const gitStart = createMatcher(FAILURE_MARKERS.git.map(({ start }) => start));
 const gitEnd = createMatcher(FAILURE_MARKERS.git.map(({ end }) => end));
 
+// Keep both ends of large diagnostics without retaining whole lines or TAP blocks.
+class FailureExcerpt {
+  head = '';
+  tail = '';
+  length = 0;
+
+  append(text) {
+    const remaining = Math.max(0, 4096 - this.head.length);
+    this.head += text.slice(0, remaining);
+    this.tail = (this.tail + text.slice(remaining)).slice(-4096);
+    this.length += text.length;
+  }
+
+  toString() {
+    const omitted = this.length > 8192 ? '\n[... failure output truncated ...]\n' : '';
+    return this.head + omitted + this.tail;
+  }
+}
+
 function fileAliases(filename) {
   const paths = new Set([filename]);
   if (filename.startsWith('test/')) {
@@ -35,15 +54,16 @@ async function * logWindows(source, overlap) {
 
   function * consume(raw) {
     raw = raw.replace(/\r/g, '');
-    let text = raw.replace(/\\+/g, '/');
-    if (afterBackslash && raw.startsWith('\\')) text = text.slice(1);
-    if (raw) afterBackslash = raw.endsWith('\\');
-    for (let offset = 0; offset < text.length;) {
-      const newline = text.indexOf('\n', offset);
-      const end = Math.min(offset + 8192, newline < 0 ? text.length : newline + 1);
-      const window = tail + text.slice(offset, end);
+    for (let offset = 0; offset < raw.length;) {
+      const newline = raw.indexOf('\n', offset);
+      const end = Math.min(offset + 8192, newline < 0 ? raw.length : newline + 1);
+      const content = raw.slice(offset, end);
+      let normalized = content.replace(/\\+/g, '/');
+      if (afterBackslash && content.startsWith('\\')) normalized = normalized.slice(1);
+      afterBackslash = content.endsWith('\\');
+      const window = tail + normalized;
       const lineEnd = end === newline + 1;
-      yield { text: window, lineStart, lineEnd };
+      yield { text: window, content, lineStart, lineEnd };
       if (lineEnd) {
         tail = '';
         lineStart = true;
@@ -57,14 +77,15 @@ async function * logWindows(source, overlap) {
 
   for await (const chunk of source) yield * consume(decoder.write(chunk));
   yield * consume(decoder.end());
-  if (tail) yield { text: `${tail}\n`, lineStart, lineEnd: true };
+  if (tail) yield { text: `${tail}\n`, content: '\n', lineStart, lineEnd: true };
 }
 
-// Each line is reduced to a filename and failure markers. Neither a giant line
-// nor a giant TAP block needs to survive in memory.
+// Retain failure markers and a bounded excerpt for each line.
 async function * failureLines(windows, matchFile) {
   let line = {};
-  for await (const { text, lineStart, lineEnd } of windows) {
+  let excerpt = new FailureExcerpt();
+  for await (const { text, content, lineStart, lineEnd } of windows) {
+    excerpt.append(content);
     line.file ??= matchFile(text, lineStart);
     line.diagnostic ||= diagnostic(text);
     line.infrastructure ||= infrastructure(text);
@@ -75,53 +96,71 @@ async function * failureLines(windows, matchFile) {
     line.gitStart ||= gitStart(text);
     line.gitEnd ||= gitEnd(text);
     if (lineEnd) {
+      line.text = excerpt.toString();
       yield line;
       line = {};
+      excerpt = new FailureExcerpt();
     }
   }
 }
 
 async function findFailure(lines) {
   let history = [];
   let followingLines = 0;
+  let diagnosticExcerpt;
   let tap = null;
   let git = null;
 
   for await (const line of lines) {
     const precedingLines = history;
-    history = [...history, line.file].slice(-5);
+    history = [...history, line].slice(-5);
     if (line.tapStart) {
-      tap = {};
+      tap = { excerpt: new FailureExcerpt() };
       followingLines = 0;
     }
     if (tap) {
+      tap.excerpt.append(line.text);
       tap.file ??= line.file;
       tap.todo ||= line.todo;
       // A later TODO can mark this as an expected failure; wait for the ending.
       if (line.tapEnd) {
-        if (!tap.todo && tap.file) return tap.file;
+        if (!tap.todo && tap.file) {
+          return { filename: tap.file, reason: tap.excerpt.toString().trimEnd() };
+        }
         tap = null;
       }
       continue;
     }
 
-    if (line.gitStart) git = {};
+    if (line.gitStart) git = { excerpt: new FailureExcerpt() };
     if (git) {
+      git.excerpt.append(line.text);
       git.file ??= line.file;
       if (line.gitEnd) {
-        if (git.file) return git.file;
+        if (git.file) return { filename: git.file, reason: git.excerpt.toString().trimEnd() };
         git = null;
       }
     }
     if (line.infrastructure || line.cpp) {
       const before = line.cpp ? 5 : 1;
-      const file = line.file || precedingLines.slice(-before).find(Boolean);
-      if (file) return file;
+      const context = [...precedingLines.slice(-before), line];
+      const filename = line.file || context.find(previous => previous.file)?.file;
+      if (filename) {
+        const excerpt = new FailureExcerpt();
+        for (const previous of context) excerpt.append(previous.text);
+        return { filename, reason: excerpt.toString().trimEnd() };
+      }
+    }
+    if (line.diagnostic) {
+      followingLines = 6;
+      diagnosticExcerpt = new FailureExcerpt();
     }
-    if (line.diagnostic) followingLines = 6;
     if (followingLines > 0) {
       followingLines--;
-      if (line.file) return line.file;
+      diagnosticExcerpt.append(line.text);
+      if (line.file) {
+        return { filename: line.file, reason: diagnosticExcerpt.toString().trimEnd() };
+      }
     }
   }
 }
 
@@ -33,7 +33,7 @@ export class ResumePRJob {
         filenames.add(filename);
       }
     }
-    const overlaps = new Set();
+    let overlap;
     const buildRequest = Object.create(request);
     buildRequest.json = async(...args) => {
       const data = await request.json(...args);
@@ -46,10 +46,10 @@ export class ResumePRJob {
     let pending = Promise.resolve();
     buildRequest.text = (url) => {
       const scan = pending.then(async() => {
-        if (!filenames.size || overlaps.size) return '';
+        if (!filenames.size || overlap) return '';
         const scanner = new FailureFileScanner(filenames);
         const match = await scanner.scan(request.stream(url));
-        if (match) overlaps.add(match);
+        if (match) overlap = { ...match, url };
         return '';
       });
       pending = scan.catch(debuglog);
@@ -62,10 +62,10 @@ export class ResumePRJob {
       debuglog(err);
     }
     await pending;
-    if (overlaps.size) {
-      for (const filename of [...overlaps].sort()) {
-        cli.error(filename);
-      }
+    if (overlap) {
+      cli.error(overlap.filename);
+      cli.info(overlap.url);
+      cli.log(overlap.reason);
       return false;
     }
     return true;