chainlesschain 0.166.136 → 0.166.139

package/src/lib/read-file-loop-guard.js

@@ -4,6 +4,7 @@ import { isToolRecoveryPaused } from "./tool-recovery-result.js";
 import { hostToolOutputIdentity } from "./tool-result-preview.js";
 import { serializeRetainedContext } from "./retained-context-preview.js";
 const MAX_FILES = 12;
+const MAX_UNDELIVERED_READS = 6;
 
 function keyFor(filePath, args) {
   return JSON.stringify([
@@ -94,6 +95,44 @@ export class ReadFileLoopGuard {
         retainContext(context);
       }
     }
+    for (const entry of this.progress.values()) {
+      for (const pending of entry.pendingPages) {
+        if (this.isPageVisible(pending.page)) {
+          entry.confirmedSpans = mergeSpan(
+            entry.confirmedSpans,
+            pending.page.readSpan,
+          );
+          if (pending.page.readSpan.end >= entry.confirmedCursorEnd) {
+            entry.confirmedCursorEnd = pending.page.readSpan.end;
+            entry.confirmedCursor = {
+              lastReadRange: pending.page.range,
+              nextRead: pending.page.nextRead || null,
+            };
+          }
+        } else {
+          entry.undeliveredReads++;
+          if (pending.reread) entry.rereads.delete(pending.reread);
+          if (pending.restoring) entry.contextRestoreOffered = false;
+        }
+      }
+      entry.pendingPages = [];
+      // Execution reserves ranges synchronously for parallel reads. Only
+      // source actually selected for the provider becomes historical coverage.
+      entry.spans = entry.confirmedSpans.map((span) => [...span]);
+      if (entry.summary) {
+        const through =
+          entry.confirmedSpans[0]?.[0] === 0 ? entry.confirmedSpans[0][1] : 0;
+        entry.summary.readThrough = through;
+        entry.summary.reachedEnd = through >= entry.total;
+        entry.summary.pendingDelivery = false;
+        if (entry.confirmedCursor)
+          Object.assign(entry.summary, entry.confirmedCursor);
+        else {
+          delete entry.summary.lastReadRange;
+          entry.summary.nextRead = null;
+        }
+      }
+    }
   }
 
   isPageVisible(page) {
@@ -103,8 +142,29 @@ export class ReadFileLoopGuard {
           keyFor(visible.path, {}) === keyFor(page.path, {}) &&
           visible.fileVersion === page.fileVersion &&
           typeof page.content === "string" &&
-          page.content.length > 0 &&
-          visible.content.includes(page.content),
+          (page.content.length > 0 || page.readSpan?.total === 0) &&
+          ((visible.readSpan &&
+            page.readSpan &&
+            visible.readSpan.total === page.readSpan.total &&
+            visible.readSpan.start <= page.readSpan.start &&
+            visible.readSpan.end >= page.readSpan.end &&
+            visible.readSpan.end - visible.readSpan.start >=
+              visible.content.length &&
+            visible.readSpan.end - visible.readSpan.start <=
+              visible.content.length + 1 &&
+            page.readSpan.end - page.readSpan.start >= page.content.length &&
+            page.readSpan.end - page.readSpan.start <=
+              page.content.length + 1 &&
+            visible.content.slice(
+              page.readSpan.start - visible.readSpan.start,
+              page.readSpan.start -
+                visible.readSpan.start +
+                page.content.length,
+            ) === page.content) ||
+            (!visible.readSpan &&
+              !visible.contentTruncated &&
+              JSON.stringify(visible.range) === JSON.stringify(page.range) &&
+              visible.content === page.content)),
       ) === true
     );
   }
@@ -166,6 +226,11 @@ export class ReadFileLoopGuard {
       entry = {
         fileVersion,
         spans: [],
+        confirmedSpans: [],
+        pendingPages: [],
+        undeliveredReads: 0,
+        confirmedCursor: null,
+        confirmedCursorEnd: 0,
         rereads: new Set(),
         summary: null,
         excerpts: [],
@@ -184,15 +249,27 @@ export class ReadFileLoopGuard {
         readProgress: { newContent: false },
       };
     }
+    if (entry.undeliveredReads >= MAX_UNDELIVERED_READS) {
+      return {
+        path: filePath,
+        fileVersion,
+        code: "CC_READ_SOURCE_NOT_DELIVERED",
+        error:
+          "Repeated file reads did not deliver source content to the model. Report this limitation or use a focused search; do not claim the file was read.",
+        contentOmitted: true,
+        reachedEnd: false,
+        readRecovery: { action: "source-unavailable" },
+      };
+    }
     let span = page.readSpan;
+    let reread;
+    let restoringPage = false;
     const covered = entry.spans.some(
       ([start, end]) => start <= span.start && end >= span.end,
     );
-    let targeted =
-      Number(args.offset) > 0 &&
-      Number(args.limit) > 0 &&
-      Number(args.limit) <= 200 &&
-      !page.truncated;
+    const explicitRange =
+      Number(args.offset) > 0 && Number(args.limit) > 0 && !page.truncated;
+    let targeted = explicitRange;
     const coveredPrefix = entry.spans.some(
       ([start, end]) => start <= span.start && end > span.start,
     );
@@ -221,6 +298,7 @@ export class ReadFileLoopGuard {
         span = page.readSpan;
         targeted = true;
         entry.contextRestoreOffered = true;
+        restoringPage = true;
       }
     }
     if (covered || (coveredPrefix && !targeted)) {
@@ -240,13 +318,14 @@ export class ReadFileLoopGuard {
         entry.rereads.size < 3
       ) {
         entry.rereads.add(fingerprint);
+        reread = fingerprint;
         page.readRecovery = {
           action: restoring ? "context-restore" : "targeted-review",
         };
         if (restoring) page.readRecovery.fileVersion = fileVersion;
       } else {
         const unread = entry.spans[0]?.[0] === 0 ? entry.spans[0][1] : 0;
-        if (unread < span.total) {
+        if (unread < span.total && !explicitRange) {
           const requestedRange = page.range;
           page = continuePage(unread);
           if (page.error || !page.readSpan) return page;
@@ -257,6 +336,24 @@ export class ReadFileLoopGuard {
           };
           newContent = true;
         } else {
+          const confirmedEnd =
+            entry.confirmedSpans[0]?.[0] === 0 ? entry.confirmedSpans[0][1] : 0;
+          if (
+            this.visiblePages !== null &&
+            !entry.confirmedSpans.some(
+              ([start, end]) => start <= span.start && end >= span.end,
+            )
+          ) {
+            return {
+              path: filePath,
+              fileVersion,
+              contentOmitted: true,
+              reachedEnd: false,
+              readProgress: { newContent: false },
+              readRecovery: { action: "pending-delivery" },
+              hint: "This range has a read pending in the current tool batch. Historical source coverage is recorded only after content reaches the model.",
+            };
+          }
           return {
             path: filePath,
             fileVersion,
@@ -264,7 +361,7 @@ export class ReadFileLoopGuard {
             hashed: args.hashed === true,
             alreadyRead: true,
             contentOmitted: true,
-            reachedEnd: true,
+            reachedEnd: confirmedEnd >= span.total,
             readProgress: { newContent: false },
             readRecovery: { action: "use-findings" },
             ...(entry.summary?.outline
@@ -272,17 +369,36 @@ export class ReadFileLoopGuard {
               : {}),
             recoveryRead: {
               path: filePath,
-              offset: 1,
+              offset: explicitRange ? page.range.startLine : 1,
               limit: 80,
               ...(args.hashed === true ? { hashed: true } : {}),
               ...(args.raw === true ? { raw: true } : {}),
             },
-            hint: "The unchanged file was read earlier, but historical coverage does not mean its source is visible now. Use any source excerpts actually present in this request. For missing details, use search_files or read_file with a specific offset and limit (at most 80 lines); recoveryRead is a bounded starting range, not permission to restart a full scan. Reading the file is not task completion.",
+            hint: "This requested range was read earlier, but historical coverage does not mean its source is visible now. The runtime has not substituted an unrelated file range. Use source actually present in this request; recover missing details with a focused search or the bounded recoveryRead. Reading the file is not task completion.",
           };
         }
       }
     }
     entry.spans = mergeSpan(entry.spans, page.readSpan);
+    entry.total = page.readSpan.total;
+    if (this.visiblePages === null) {
+      // Direct tool consumers without provider selection keep synchronous
+      // semantics. Agent runs observe the initial request before any reads.
+      entry.confirmedSpans = entry.spans.map((span) => [...span]);
+    } else {
+      entry.pendingPages.push({
+        page: {
+          path: page.path,
+          fileVersion: page.fileVersion,
+          content: page.content,
+          readSpan: { ...page.readSpan },
+          ...(page.range ? { range: { ...page.range } } : {}),
+          ...(page.nextRead ? { nextRead: { ...page.nextRead } } : {}),
+        },
+        reread,
+        restoring: restoringPage,
+      });
+    }
     entry.lastReadRequest = this.visibleRequest;
     // Coverage alone cannot restore source code after compaction. Keep bounded
     // observed pages for every file type, not only large Markdown outlines.
@@ -302,10 +418,12 @@ export class ReadFileLoopGuard {
       ].slice(-2);
     }
     const allRead =
-      entry.spans[0]?.[0] === 0 && entry.spans[0][1] >= page.readSpan.total;
+      entry.confirmedSpans[0]?.[0] === 0 &&
+      entry.confirmedSpans[0][1] >= page.readSpan.total;
     // A read of the tail alone must never imply coverage of earlier sections.
     const previousEnd = entry.summary?.readThrough || 0;
-    const updateCursor = page.readSpan.end >= previousEnd;
+    const updateCursor =
+      this.visiblePages === null && page.readSpan.end >= previousEnd;
     entry.summary = {
       ...entry.summary,
       path: filePath,
@@ -317,8 +435,16 @@ export class ReadFileLoopGuard {
           }
         : {}),
       reachedEnd: allRead,
+      ...(this.visiblePages !== null ? { pendingDelivery: true } : {}),
       ...(page.outline ? { outline: page.outline } : {}),
     };
+    if (updateCursor) {
+      entry.confirmedCursorEnd = page.readSpan.end;
+      entry.confirmedCursor = {
+        lastReadRange: page.range,
+        nextRead: page.nextRead || null,
+      };
+    }
     this.progress.delete(key);
     this.progress.set(key, entry);
     // Discard pathological fragmented coverage instead of inventing coverage.
@@ -336,6 +462,13 @@ export class ReadFileLoopGuard {
     // as another duplicate would immediately schedule another "one-turn"
     // pause and prevent read_file from ever becoming available again.
     if (isToolRecoveryPaused(result)) return;
+    if (
+      tool === "read_file" &&
+      result?.code === "CC_READ_SOURCE_NOT_DELIVERED"
+    ) {
+      this.repeatedBatches = Math.max(this.repeatedBatches, 6);
+      return;
+    }
     if (
       !this.batch ||
       result?.error ||

package/src/lib/read-file-page.js

@@ -1,3 +1,5 @@
+import { recoverCompleteSourceRead } from "./source-read-recovery.js";
+
 /** Build a bounded read result with a cursor describing what was actually read. */
 export function buildReadFilePage(
   rendered,
@@ -61,7 +63,7 @@ export function buildReadFilePage(
   const charEnd = truncated
     ? charStart + count
     : lines.slice(0, end).reduce((n, line) => n + line.length + 1, 0);
-  return {
+  const page = {
     path: filePath,
     ...(fileVersion ? { fileVersion } : {}),
     ...(offset || limit || column > 1 || truncated
@@ -96,6 +98,7 @@ export function buildReadFilePage(
     hashed: args.hashed === true,
     content,
   };
+  return recoverCompleteSourceRead(page, rendered, args, maxChars);
 }
 
 /** A bounded navigation index, not a substitute for reading the cited lines. */

package/src/lib/source-read-recovery.js

@@ -0,0 +1,89 @@
+import { parse } from "acorn";
+import { canProjectHostToolExcerpt } from "./tool-result-preview.js";
+
+/**
+ * A cut source container is not safe evidence. Recover its complete top-level
+ * statements from the very same read snapshot, with explicit range metadata.
+ * This does not exempt source from either projection or provider sanitization.
+ */
+export function recoverCompleteSourceRead(page, source, args, maxChars) {
+  if (
+    typeof page?.content !== "string" ||
+    typeof page.fileVersion !== "string" ||
+    !/\.(?:[cm]?js)$/iu.test(page.path || "") ||
+    args.hashed === true ||
+    !page.range ||
+    !page.readSpan ||
+    source.length > 512 * 1024 ||
+    canProjectHostToolExcerpt(page.content, "read_file")
+  )
+    return page;
+
+  let program;
+  let tokens = 0;
+  try {
+    program = parse(source, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowReturnOutsideFunction: true,
+      onToken() {
+        if (++tokens > 32768)
+          throw new RangeError("Source recovery token bound");
+      },
+    });
+  } catch {
+    // Malformed or oversized source retains the ordinary omission boundary.
+    return page;
+  }
+  const statements = program.body.filter(
+    (node) => node.start < page.readSpan.end && node.end > page.readSpan.start,
+  );
+  if (!statements.length) return page;
+  const start = Math.min(
+    page.readSpan.start,
+    source.lastIndexOf("\n", statements[0].start - 1) + 1,
+  );
+  const followingNewline = source.indexOf("\n", statements.at(-1).end);
+  const end = Math.max(
+    page.readSpan.end,
+    followingNewline < 0 ? source.length : followingNewline + 1,
+  );
+  const content = source.slice(start, end);
+  if (
+    content === page.content ||
+    !canProjectHostToolExcerpt(content, "read_file")
+  )
+    return page;
+  const startLine = 1 + (source.slice(0, start).match(/\n/gu) || []).length;
+  const endLine =
+    startLine +
+    (content.match(/\n/gu) || []).length -
+    (content.endsWith("\n") ? 1 : 0);
+  const recovered = {
+    ...page,
+    content,
+    range: { startLine, endLine, totalLines: page.range.totalLines },
+    readSpan: { start, end, total: source.length },
+    sourceRecovery: {
+      action: "complete-source-container",
+      fileVersion: page.fileVersion,
+      requestedRange: { ...page.range },
+      requestedSpan: { ...page.readSpan },
+      note: "The requested excerpt cut a source container. These complete surrounding statements come from the same file version; the range and readSpan describe the content actually returned.",
+    },
+  };
+  delete recovered.truncated;
+  delete recovered.size;
+  delete recovered.nextRead;
+  delete recovered.hint;
+  if (end < source.length) {
+    recovered.nextRead = { ...args, offset: endLine + 1, column: 1 };
+    recovered.hint = "Continue with nextRead only if more source is needed.";
+  }
+  // The read guard, host telemetry and delivery envelope still add metadata.
+  // Reuse the ordinary page's headroom: an almost-full recovery would be
+  // projected back to an omission by the final cap before reaching a provider.
+  return JSON.stringify(recovered).length <= Math.max(0, maxChars - 2048)
+    ? recovered
+    : page;
+}

package/src/lib/tool-result-preview.js

@@ -1,6 +1,7 @@
 import {
   createEvidenceJsonTextBoundary,
   AGENT_CODE_TEXT_RESULT_TOOLS,
+  EVIDENCE_JSON_POLICY,
 } from "./evolution/evidence-json-text.js";
 import { createHash } from "node:crypto";
 
@@ -32,8 +33,12 @@ const PREVIEW_HINT =
   "Tool output truncated. Narrow the request: filter/count locally, select fields, search_files, or read_file with offset/limit. Omitted text is not full-output evidence.";
 
 /** Check only host-created excerpts; original uncut tool text still reaches ingress. */
-function completeExcerpt(text, tool) {
-  const scan = createEvidenceJsonTextBoundary((message) => new Error(message));
+export function canProjectHostToolExcerpt(text, tool) {
+  const scan = createEvidenceJsonTextBoundary((message) => new Error(message), {
+    ...EVIDENCE_JSON_POLICY,
+    sourceLiteralPolicy: "explicit-source-containers-v1",
+    maxSourceTokens: 32768,
+  });
   const visit = (value, layer) => {
     if (typeof value === "string") return project(value, layer);
     if (Array.isArray(value)) return value.map((child) => visit(child, layer));
@@ -48,6 +53,7 @@ function completeExcerpt(text, tool) {
     scan(value, {
       layer,
       codeText: AGENT_CODE_TEXT_RESULT_TOOLS.includes(tool),
+      sourceText: layer === 0,
       visit,
       plain: (plain) => plain,
       equal: (left, right) => JSON.stringify(left) === JSON.stringify(right),
@@ -233,9 +239,13 @@ export function safeHostToolResultForModel(tool, result) {
   let safe = result;
   for (const field of fields) {
     const text = result[field];
-    if (typeof text !== "string" || completeExcerpt(text, tool)) continue;
+    if (typeof text !== "string" || canProjectHostToolExcerpt(text, tool))
+      continue;
     if (safe === result) safe = { ...result };
-    safe[field] = omitted(text.length);
+    safe[field] =
+      tool === "read_file"
+        ? `Text omitted (${text.length} chars); this excerpt could not be safely projected. Read a complete surrounding statement or container; expand the range or read the full file within existing size limits when necessary. Omitted content has not been inspected.`
+        : omitted(text.length);
     safe[`${field}Omitted`] = true;
     safe[`${field}OmittedChars`] = text.length;
   }
@@ -259,7 +269,10 @@ export function boundedCommandOutput(output, max, tool = "run_code") {
       output,
       Math.max(1, Math.floor(max / 2)),
     );
-    if (JSON.stringify(preview).length <= max && completeExcerpt(preview, tool))
+    if (
+      JSON.stringify(preview).length <= max &&
+      canProjectHostToolExcerpt(preview, tool)
+    )
       return preview;
   } else if (!/[{}\[\]"']/u.test(output)) {
     let low = 0;

package/src/repl/agent-repl.js

@@ -3544,6 +3544,7 @@ async function startAgentReplInWorkspaceOwned(
   });
   if (feature("PROMPT_COMPRESSOR") || contextMemoryCutover.canonical) {
     _compressor = new PromptCompressor({
+      contextMemoryModelWindowTokens: options.contextMemoryModelWindowTokens,
       model,
       provider,
       llmQuery: async (prompt) => {
@@ -9852,6 +9853,7 @@ async function startAgentReplInWorkspaceOwned(
         usageEvents,
         thinking: reasoning,
       } = await agentLoop(messages, {
+        contextMemoryModelWindowTokens: options.contextMemoryModelWindowTokens,
         ...captureSkillRuntimeDependencies(options),
         ...liveOpts,
         waitForOutput: _replOutputFlow.wait,