chainlesschain 0.166.135 → 0.166.138

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,7 +249,21 @@ 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,
     );
@@ -221,6 +300,7 @@ export class ReadFileLoopGuard {
         span = page.readSpan;
         targeted = true;
         entry.contextRestoreOffered = true;
+        restoringPage = true;
       }
     }
     if (covered || (coveredPrefix && !targeted)) {
@@ -240,6 +320,7 @@ export class ReadFileLoopGuard {
         entry.rereads.size < 3
       ) {
         entry.rereads.add(fingerprint);
+        reread = fingerprint;
         page.readRecovery = {
           action: restoring ? "context-restore" : "targeted-review",
         };
@@ -257,6 +338,19 @@ export class ReadFileLoopGuard {
           };
           newContent = true;
         } else {
+          const confirmedEnd =
+            entry.confirmedSpans[0]?.[0] === 0 ? entry.confirmedSpans[0][1] : 0;
+          if (this.visiblePages !== null && confirmedEnd < span.total) {
+            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,
@@ -283,6 +377,25 @@ export class ReadFileLoopGuard {
       }
     }
     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 +415,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 +432,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 +459,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/safe-mode.js

@@ -83,3 +83,13 @@ export function bareModeRequested(opts = {}, env = process.env) {
   const raw = env.CC_BARE;
   return raw != null && /^(1|true|yes|on)$/i.test(String(raw).trim());
 }
+
+/** Apply independent saved restrictions without enabling the rest of bare mode. */
+export function applyCustomizationOptions(options, env = process.env) {
+  if (options.plugins === false) env.CC_PLUGINS = "0";
+  if (options.mcpAutoConnect === false) {
+    options.mcp = false;
+    for (const field of ["ide", "pdh", "jetbrains"])
+      if (options[field] === undefined) options[field] = false;
+  }
+}

package/src/lib/session-history-origins.js

@@ -108,6 +108,42 @@ export function createSessionHistoryOrigins() {
     },
     branchPrefix(messages, head, count) {
       if (!context) return null;
+      // A branch may retain the complete verified context. A rewind must remove
+      // something, so its strict-prefix admission cannot decide this case.
+      if (messages.length === context.length) {
+        if (
+          !/^[a-f0-9]{64}$/u.test(head) ||
+          !Number.isSafeInteger(count) ||
+          count < 0 ||
+          context.some(
+            (entry) =>
+              historyBearing(entry) &&
+              (!entry.origin ||
+                !Number.isSafeInteger(entry.origin.first) ||
+                !Number.isSafeInteger(entry.origin.last) ||
+                entry.origin.first < 0 ||
+                entry.origin.last < entry.origin.first ||
+                entry.origin.last >= count),
+          )
+        )
+          return null;
+        try {
+          if (
+            fingerprint(context.map((entry) => entry.message)) !==
+            fingerprint(messages)
+          )
+            return null;
+        } catch {
+          return null;
+        }
+        return {
+          cutoff: count,
+          entries: context.map((entry) => ({
+            message: entry.message,
+            origin: entry.origin ? { ...entry.origin } : null,
+          })),
+        };
+      }
       const cutoff = api.rewind(
         {
           prevHash: head,

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";
 
@@ -33,7 +34,11 @@ const PREVIEW_HINT =
 
 /** Check only host-created excerpts; original uncut tool text still reaches ingress. */
 function completeExcerpt(text, tool) {
-  const scan = createEvidenceJsonTextBoundary((message) => new Error(message));
+  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),
@@ -235,7 +241,10 @@ export function safeHostToolResultForModel(tool, result) {
     const text = result[field];
     if (typeof text !== "string" || completeExcerpt(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;
   }

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,

package/src/runtime/agent-core.js

@@ -1,4 +1,7 @@
-import { projectMessagesWithTaskBinding } from "./message-roles.js";
+import {
+  projectMessagesWithTaskBinding,
+  getTaskCompactionBindings,
+} from "./message-roles.js";
 import {
   providerFetch,
   requireUnscopedToolExecution,
@@ -12375,7 +12378,10 @@ export async function chatWithTools(rawMessages, options) {
           ),
         {
           signal,
-          retries: options.workflowEffectId ? 0 : undefined,
+          retries:
+            options.workflowEffectId || options.disableTransportRetry === true
+              ? 0
+              : undefined,
           strictRetryObserver: options.strictUsageTelemetry === true,
           ...(typeof options.onStreamRetry === "function"
             ? {
@@ -12527,7 +12533,10 @@ export async function chatWithTools(rawMessages, options) {
           ),
         {
           signal,
-          retries: options.workflowEffectId ? 0 : undefined,
+          retries:
+            options.workflowEffectId || options.disableTransportRetry === true
+              ? 0
+              : undefined,
           strictRetryObserver: options.strictUsageTelemetry === true,
           ...(typeof options.onStreamRetry === "function"
             ? {
@@ -12655,7 +12664,10 @@ export async function chatWithTools(rawMessages, options) {
           ),
         {
           signal,
-          retries: options.workflowEffectId ? 0 : undefined,
+          retries:
+            options.workflowEffectId || options.disableTransportRetry === true
+              ? 0
+              : undefined,
           strictRetryObserver: options.strictUsageTelemetry === true,
           ...(typeof options.onStreamRetry === "function"
             ? {
@@ -12720,7 +12732,10 @@ export async function chatWithTools(rawMessages, options) {
         ),
       {
         signal,
-        retries: options.workflowEffectId ? 0 : undefined,
+        retries:
+          options.workflowEffectId || options.disableTransportRetry === true
+            ? 0
+            : undefined,
         strictRetryObserver: options.strictUsageTelemetry === true,
         ...(typeof options.onStreamRetry === "function"
           ? {
@@ -12768,7 +12783,10 @@ export async function chatWithTools(rawMessages, options) {
         ),
       {
         signal,
-        retries: options.workflowEffectId ? 0 : undefined,
+        retries:
+          options.workflowEffectId || options.disableTransportRetry === true
+            ? 0
+            : undefined,
         strictRetryObserver: options.strictUsageTelemetry === true,
         ...(typeof options.onStreamRetry === "function"
           ? {
@@ -14607,6 +14625,9 @@ async function _getAutoCompactor(options) {
                     onToken: undefined,
                     onStall: undefined,
                     onStreamRetry: undefined,
+                    // Summary spend is settled once at the compactor boundary.
+                    // A second transport attempt would bypass that accounting.
+                    disableTransportRetry: true,
                     providerRequestId:
                       requestBinding?.providerRequestId || undefined,
                     maxOutputTokens,
@@ -14642,6 +14663,7 @@ async function _getAutoCompactor(options) {
             return compactLiveMessagesCanonical(messages, {
               compressor: compatibilitySummarizer,
               compressOptions,
+              requiredUserBindings: compressOptions.requiredUserBindings,
               sessionId: options.sessionId,
               operationId: `auto-${randomUUID()}`,
               provider: options.provider || "ollama",
@@ -14979,6 +15001,11 @@ export async function* agentLoop(messages, options) {
           ).length === 1,
       }
     : null;
+  const taskCompactionBindings = getTaskCompactionBindings(
+    options.projectProviderMessages,
+    messages,
+    currentUserTaskBinding,
+  );
   if (options.serviceTier != null) {
     resolveModelServiceTier(
       resolveModelCapabilityProfile(options),
@@ -15901,6 +15928,7 @@ export async function* agentLoop(messages, options) {
               }
             : await compactor.compress(workingMessages, {
                 preserveToolPairs: true,
+                requiredUserBindings: taskCompactionBindings,
                 ...pinOpts,
               });
           if (
@@ -15936,6 +15964,9 @@ export async function* agentLoop(messages, options) {
                   reason:
                     stats.summaryUsageUnknownReason ||
                     "provider_transport_outcome_unknown",
+                  ...(stats.summaryProviderError
+                    ? { providerError: stats.summaryProviderError }
+                    : {}),
                 };
               }
             }
@@ -16042,6 +16073,9 @@ export async function* agentLoop(messages, options) {
                   ? compactionUsageCall.model
                   : stats.summaryModel || options.model || null,
               reason: unknownReason,
+              ...(stats.summaryProviderError
+                ? { providerError: stats.summaryProviderError }
+                : {}),
               code:
                 unknownReason === "provider_usage_not_reported"
                   ? "provider_usage_missing"

package/src/runtime/headless-runner.js

@@ -2942,6 +2942,7 @@ async function runAgentHeadlessInWorkspace(
     });
   };
   const loopOptions = {
+    contextMemoryModelWindowTokens: options.contextMemoryModelWindowTokens,
     ...(evolutionIngress === null ? {} : { evolutionIngress }),
     model,
     provider,

package/src/runtime/headless-stream.js

@@ -964,6 +964,7 @@ async function runTurn(
   let endReason = "complete";
   let stopForCost = false;
   let stopForCompactionUsageUnknown = false;
+  let compactionUsageUnknown = null;
   let responseCompleted = false;
   // P0-2: the side-effect op currently in flight (at most one — the loop runs
   // tools serially). Non-null only between a dangerous tool's tool-executing
@@ -1223,6 +1224,7 @@ async function runTurn(
         }
         break;
       case "compaction-usage-unknown":
+        compactionUsageUnknown = compactionUsageUnknownDiagnostic(event);
         if (event.ledgerPersisted !== true) {
           persistUsageEvent?.({
             ...event,
@@ -1282,7 +1284,52 @@ async function runTurn(
   ) {
     sideEffects.persist();
   }
-  return { finalText, endReason, usage, toolCalls };
+  return { finalText, endReason, usage, toolCalls, compactionUsageUnknown };
+}
+
+function compactionUsageUnknownDiagnostic(event) {
+  const reason =
+    event?.reason === "provider_usage_not_reported"
+      ? "provider_usage_not_reported"
+      : "provider_transport_outcome_unknown";
+  const providerError = event?.providerError;
+  const providerHints = {
+    authentication:
+      "Provider authentication failed; check the API credentials.",
+    access_denied: "Provider access was denied; check model permissions.",
+    rate_limit: "The provider rate limit was reached; wait before resuming.",
+    server_error:
+      "The provider returned a server error; check service availability.",
+    http_error:
+      "The provider rejected the compaction request; check the model endpoint.",
+    network: "The model connection failed; check network and proxy settings.",
+    invalid_response:
+      "The provider returned an invalid response; check API compatibility.",
+    unknown: "The provider request failed.",
+  };
+  const category = providerError?.category;
+  const projected = Object.hasOwn(providerHints, category || "")
+    ? {
+        category,
+        ...(Number.isInteger(providerError.httpStatus) &&
+        providerError.httpStatus >= 400 &&
+        providerError.httpStatus <= 599
+          ? { httpStatus: providerError.httpStatus }
+          : {}),
+      }
+    : null;
+  return {
+    code: "CC_COMPACTION_USAGE_UNKNOWN",
+    usage_unknown_reason: reason,
+    ...(projected ? { provider_error: projected } : {}),
+    error:
+      (reason === "provider_usage_not_reported"
+        ? "Compaction provider did not report valid token usage"
+        : "Compaction request failed before provider usage could be confirmed") +
+      "; the session stopped without retrying the request. " +
+      (projected ? providerHints[category] + " " : "") +
+      "Review the saved session and provider usage, check the model connection, then resume explicitly.",
+  };
 }
 
 /**
@@ -3821,6 +3868,31 @@ async function runAgentHeadlessStreamInWorkspace(
         { code: "CC_SESSION_TOOL_ROUND_SETTLEMENT_HEAD_UNKNOWN" },
       );
     }
+    // Only a new, acknowledged tool_round has item positions to associate
+    // with live IDE output. A no-op settlement returns an existing head only.
+    if (appended.event?.type === "tool_round") {
+      const items = appended.event.data.messages.map((message, itemIndex) => ({
+        itemIndex,
+        role: message.role,
+        toolCallId:
+          message.role === "assistant"
+            ? message.tool_calls[0].id
+            : message.tool_call_id,
+      }));
+      for (let offset = 0; offset < items.length; offset += 100) {
+        emit({
+          type: "system",
+          subtype: "tool_round_persisted",
+          session_id: sessionId,
+          transcript_refs: {
+            schema: "chainlesschain.session-tool-round-references/v1",
+            sessionId,
+            eventId: appended.hash,
+            items: items.slice(offset, offset + 100),
+          },
+        });
+      }
+    }
     return appended;
   };
   const settleToolRoundsForHost = (phase, clientMessageId = null) => {
@@ -3873,6 +3945,7 @@ async function runAgentHeadlessStreamInWorkspace(
     return settleToolRoundsForHost(phase);
   };
   const loopOptionsBase = {
+    contextMemoryModelWindowTokens: options.contextMemoryModelWindowTokens,
     ...(evolutionIngress === null ? {} : { evolutionIngress }),
     reviewChanges: options.reviewChanges === true,
     model,
@@ -4851,9 +4924,11 @@ async function runAgentHeadlessStreamInWorkspace(
             type: "result",
             subtype: "error_compaction_usage_unknown",
             is_error: true,
-            code: "CC_COMPACTION_USAGE_UNKNOWN",
-            error:
-              "Compaction provider usage is unknown; the paid compaction is not retried",
+            ...compactionUsageUnknownDiagnostic(
+              compatibilityResult?.usageUnknownEvent || {
+                reason: "provider_transport_outcome_unknown",
+              },
+            ),
             session_id: sessionId,
           });
           sawError = true;
@@ -4905,9 +4980,7 @@ async function runAgentHeadlessStreamInWorkspace(
           type: "result",
           subtype: "error_compaction_usage_unknown",
           is_error: true,
-          code: "CC_COMPACTION_USAGE_UNKNOWN",
-          error:
-            "Compaction provider usage is unknown; the paid compaction is not retried",
+          ...compactionUsageUnknownDiagnostic(usageUnknownEvent),
           session_id: sessionId,
           ...(costBudget ? { budget_state: "unverifiable" } : {}),
         });
@@ -5908,9 +5981,8 @@ async function runAgentHeadlessStreamInWorkspace(
         type: "result",
         subtype: "error_compaction_usage_unknown",
         is_error: true,
-        code: "CC_COMPACTION_USAGE_UNKNOWN",
-        error:
-          "Compaction provider usage is unknown; the paid compaction is not retried",
+        ...(outcome.compactionUsageUnknown ||
+          compactionUsageUnknownDiagnostic(null)),
         session_id: sessionId,
         turn: turns,
         usage: outcome.usage,

package/src/runtime/message-roles.js

@@ -166,6 +166,34 @@ export function createResumeRoleProjection(messages) {
   return projection;
 }
 
+/** Capture the original user sources needed by an owned resume merge. */
+export function getTaskCompactionBindings(projection, input, taskBinding) {
+  if (!taskBinding) return [];
+  const owned = RESUME_ROLE_PROJECTIONS.get(projection);
+  const capture = (binding) => ({
+    ...binding,
+    matchCount: input.filter((message) =>
+      isDeepStrictEqual(message, binding.message),
+    ).length,
+  });
+  if (!owned) return [capture(taskBinding)];
+  const sourceIndex = input.indexOf(taskBinding.original);
+  const group = owned(input).sources.find((indices) =>
+    indices.includes(sourceIndex),
+  );
+  return (group || [sourceIndex]).map((index) => {
+    if (index === sourceIndex) return capture(taskBinding);
+    const original = input[index];
+    return capture({
+      original,
+      message: JSON.parse(canonicalJson(original)),
+      allowContentRelocation:
+        input.filter((message) => isDeepStrictEqual(message, original))
+          .length === 1,
+    });
+  });
+}
+
 /**
  * Preserve a bound task through this module's exact, captured resume merges.
  * Arbitrary callbacks, wrappers and forged properties never receive lineage.

package/src/runtime/policies/agent-policy.js

@@ -23,6 +23,7 @@ export function resolveAgentPolicy({
 
   return {
     model: connection.model || defaults.model || "qwen2:7b",
+    contextMemoryModelWindowTokens: overrides.contextMemoryModelWindowTokens,
     visionModel: overrides.visionModel,
     provider: connection.provider,
     baseUrl: connection.baseUrl,