fix(read-file): window scan-capped lines so no tail is silently lost

A single line past the 8MB scan ceiling was truncated to 2000 chars under a continuation footer whose offset skipped the unshown middle. The scan-capped remainder is now windowed like smaller overlong lines, so every scanned byte reassembles through offset continuation.

Author: TheGreatAxios

src/plugins/read-file-guard-plugin.test.ts

@@ -165,7 +165,7 @@ describe("readFileBounded", () => {
     expect(content).not.toContain("continue");
   });
 
-  test("a newline-less file past the scan ceiling returns content, not empty", async () => {
+  test("a newline-less file past the scan ceiling returns a windowed page, not empty", async () => {
     const giant = "a".repeat(READ_FILE_MAX_SCAN_BYTES + 1024);
     const p = await fixture("giant-line.txt", giant);
     const { content, isError } = await readFileBounded(
@@ -177,7 +177,21 @@ describe("readFileBounded", () => {
     expect(isError).toBeUndefined();
     expect(content.length).toBeGreaterThan(0);
     expect(content).toContain("     1\t");
-    expect(content).toContain("scan limit");
+    // The scan-capped remainder is windowed like a smaller overlong line, so
+    // the footer offers a deliverable offset page instead of a truncated line
+    // under a scan notice whose tail is unreachable.
+    expect(content).not.toContain("line truncated");
+    expect(content).not.toContain("scan limit");
+    expect(content).toContain("output limit");
+    expect(content).toContain("Use offset=");
+    const body = content.split("\n\n")[0] ?? "";
+    const numbered = body.trimEnd().split("\n");
+    expect(numbered.length).toBeGreaterThan(1);
+    for (const line of numbered) {
+      expect(line.replace(/^\s*\d+\t/, "").length).toBeLessThanOrEqual(
+        READ_FILE_MAX_LINE_LENGTH,
+      );
+    }
   });
 
   test("abort rejects with read_file timeout guidance", async () => {
@@ -446,6 +460,37 @@ describe("CL-8979 large-file pagination", () => {
     expect(collected).toContain("END");
   });
 
+  test("windows a single file line past the scan ceiling with exact reassembly", async () => {
+    const filler = "0123456789ABCDEF".repeat(
+      Math.ceil((READ_FILE_MAX_SCAN_BYTES + 4096) / 16),
+    );
+    const payload = `HEAD-${filler}-TAIL`;
+    expect(payload.length).toBeGreaterThan(READ_FILE_MAX_SCAN_BYTES);
+    const p = await fixture("cl8979-scan-giant.txt", `${payload}\nEND\n`);
+    const rows: string[] = [];
+    let offset = 0;
+    let hops = 0;
+    for (;;) {
+      const res = await readFileBounded(p, offset, 2000, neverAbort());
+      hops += 1;
+      expect(res.isError).toBeUndefined();
+      const content = String(res.content);
+      // No silent tail loss: every scanned byte is windowed, never truncated,
+      // and no footer promises continuation it cannot deliver.
+      expect(content).not.toContain("line truncated");
+      expect(content).not.toContain("scan limit");
+      rows.push(...bodyRows(content));
+      const next = continueOffset(content);
+      if (next === null) break;
+      expect(next).toBeGreaterThan(offset);
+      offset = next;
+      expect(hops).toBeLessThan(500);
+    }
+    expect(hops).toBeGreaterThan(1);
+    expect(rows[rows.length - 1]).toBe("END");
+    expect(rows.slice(0, -1).join("")).toBe(payload);
+  }, 180_000);
+
   test("a large-file page passes the result-truncation layer byte-identical", async () => {
     const name = "cl8979-page.txt";
     const rows = Array.from(

src/plugins/read-file-guard-plugin.ts

@@ -125,10 +125,6 @@ function readStreamBounded(
     let truncReason: TruncReason | undefined;
     let endReached = false;
     let settled = false;
-    // Set when the scan ceiling trips: the trailing partial is reported
-    // truncated (never windowed), so a line longer than one scan pass keeps
-    // the scan-limit notice instead of a byte-limit page.
-    let scanCapped = false;
 
     const out: string[] = [];
 
@@ -198,13 +194,10 @@ function readStreamBounded(
           if (pending.length > READ_FILE_MAX_LINE_LENGTH && !windowHugeLines) {
             pending = pending.slice(0, READ_FILE_MAX_LINE_LENGTH);
             pendingOverflow = true;
-          } else if (
-            windowHugeLines &&
-            pending.length > READ_FILE_MAX_SCAN_BYTES
-          ) {
-            pending = pending.slice(0, READ_FILE_MAX_LINE_LENGTH);
-            pendingOverflow = true;
           }
+          // windowHugeLines keeps the full pending: the scan trip ends the
+          // stream, and flushRemainder windows the remainder so every scanned
+          // byte stays reachable through offset continuation.
           return true;
         }
         const line = pending.slice(0, nl);
@@ -227,9 +220,11 @@ function readStreamBounded(
         emitWrapped(pending, true);
         return;
       }
+      // Windowed even when scan-capped: every window burns a line number,
+      // so the footer's offset resumes at the next window instead of promising
+      // continuation that skips the unshown middle of an overlong line.
       if (
         !pendingOverflow &&
-        !scanCapped &&
         windowHugeLines &&
         pending.length > contentBudget
       ) {
@@ -290,7 +285,6 @@ function readStreamBounded(
         return;
       }
       if (scanned >= READ_FILE_MAX_SCAN_BYTES) {
-        scanCapped = true;
         flushRemainder();
         if (truncReason === undefined) truncReason = "scan";
         finishOk();