chainlesschain 0.166.131 → 0.166.132

package/README.md

@@ -2,11 +2,21 @@
 
 Command-line interface for installing, configuring, and managing [ChainlessChain](https://www.chainlesschain.com), including the coding agent, governed tools, sessions, memory, and IDE integrations.
 
-## Source candidate 0.166.131 (unreleased)
+## Source candidate 0.166.132 (unreleased, 2026-10-30)
 
-Main now prepares CLI **0.166.131** with Kernel **0.1.11**, Open VSX **0.37.169** and JetBrains **0.4.186** source candidates. It contains the later independent Goal, Memory, MCP/Skills, temporary-worktree and Terra changes; the verified public installation below remains `.130`. Publish and verify the changed kernel first, then require complete Linux/Windows/macOS CLI CI and Strict Sandbox at the exact new source, OIDC publication and public readback before releasing IDEs. No candidate release tag or publication is created by this preparation; 34/45 acceptance and the original unresolved dispatch remain unchanged.
+CLI **0.166.132** keeps Kernel **0.1.11** and pairs with Open VSX **0.37.170** / JetBrains **0.4.187** source candidates. The candidate CLI stops tools from running on a truncated response and can replan once when complete usage has been recorded and budget remains. Recovery keeps the original task available even in a small context window. Filtered responses, explicitly incomplete terminal responses, and missing task context now stop with a clear failure. Resuming a session preserves task identity when the built-in adapter combines message roles; custom callbacks and unverified metadata cannot claim that identity. After asynchronous recall, the CLI rechecks the task and its position before continuing. The readContext continuation now moves the same complete user message by its exact index, preserving metadata and avoiding duplicate task identity. The original four independent-process restart cases passed locally, and 16 host-continuation tests passed; the latest full combined validation passed 456 tests across 18 files and 10 real CLI tests across 3 files, with no skips (5 output-limit, 1 resume and 4 compaction-memory-restart). Source 7f8ef64b4bd8b429f97d2e121c440143ed7ddf3b was superseded before publication after CLI CI found four failures in each Ubuntu and Windows E2E shard 4 job (147 passed each). Its 452+6 local preparation and successful Strict Sandbox (6/6) and Kernel (3/3) checks remain historical; remaining CLI and IDE jobs were canceled, and no release tag was created. The earlier 417+5 result also remains historical. A new exact-source release matrix is required. This candidate is not published, and the original broker evaluation remains unresolved. Require complete exact-source Linux/Windows/macOS CLI CI and Strict Sandbox, OIDC publication and public readback before releasing the paired IDEs. The verified public versions and installation below remain **0.166.131 / 0.37.169 / 0.4.186**; PC/mobile remain independent **v5.0.3.143**.
 
-## CLI 0.166.130 — current public release (2026-10-29)
+## CLI 0.166.131 — current public release (2026-10-29)
+
+Install: `npm i -g chainlesschain@0.166.131 --registry https://registry.npmjs.org`. Kernel **0.1.11** was published first. Restart the chat host, then run `cc --version` and `cc doctor`. Public Open VSX **0.37.169** / JetBrains **0.4.186** both recommend CLI **0.166.131**; their downloaded packages match the official CI payloads. Microsoft Marketplace is deferred.
+
+This release includes explicit independent Goal `verify:` checks, Memory directory identity and cancellation fixes, MCP subtask and late-connection isolation, Skills download cancellation, rule refresh around compaction, temporary-worktree lifetime fixes and updated Terra capability/billing contracts. Exact-source three-OS CLI / Strict / Kernel checks passed. [OIDC publication](https://github.com/chainlesschain/chainlesschain/actions/runs/40862685540) and [independent public readback](https://github.com/chainlesschain/chainlesschain/actions/runs/40866417524) verified immutable package bytes and signed provenance. [Publication evidence](../../docs/research/cli/evidence/release131-public/publication.json).
+
+Cumulative accepted tasks remain **34/45**, with **11** unfinished. Full Memory SLO, semantic quality and both IDE journeys remain separate acceptance work; the current native generation driver does not automatically use `verify:`. **NOT_PAID_READY / NOT_ADMITTED / HOLD** remain. PC/mobile retain their independent **v5.0.3.143** release. Older notes below retain their historical scope.
+
+[.131 upgrade guide](https://docs.chainlesschain.com/chainlesschain/cli-ide-update-2026-10-29-131.html) · [Runtime design](https://design.chainlesschain.com/release-runtime-update-2026-10-29-131.html).
+
+## CLI 0.166.130 — previous public release (2026-10-29)
 
 Install the verified public package with `npm i -g chainlesschain@0.166.130 --registry https://registry.npmjs.org`. Public Open VSX **0.37.168** and approved JetBrains **0.4.185** both recommend `.130`; restart the chat host and run `cc --version` and `cc doctor`. Microsoft Marketplace remains unpublished; use Open VSX or its versioned VSIX.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.166.131",
+  "version": "0.166.132",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/assets/linux-subreaper/linux-arm64/manifest.json

@@ -6,5 +6,5 @@
   "imageDigest": "sha256:6395a47a5bd9b038303e94a5e93754258c8480dab64635460f973eb93dc6f4d8",
   "bytes": 778808,
   "linkage": "static",
-  "commit": "c9d0bab231850697df38f2d476c2dd974cbcb6c0"
+  "commit": "772fcdbda85bcf91df95bfced5b476dcf4c74614"
 }

package/src/assets/linux-subreaper/linux-x64/manifest.json

@@ -6,5 +6,5 @@
   "imageDigest": "sha256:f162e55ad3f3f72f8a52e9d7f12b5b8db44506c2ca66a14d7d62d5cd4f12498e",
   "bytes": 934160,
   "linkage": "static",
-  "commit": "c9d0bab231850697df38f2d476c2dd974cbcb6c0"
+  "commit": "772fcdbda85bcf91df95bfced5b476dcf4c74614"
 }

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.132",
+      "cliVersions": ["0.166.132"],
+      "date": "2026-10-30",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.132: output-limit integrity and bounded recovery (candidate, 2026-10-30)",
+          "body": "- Preserve OpenAI-compatible chat-completions termination evidence in JSON and streaming responses. A response ending with `length` cannot execute any of its tool calls or become a successful final answer, even when its arguments happen to be valid JSON.\n- Settle complete physical-call usage before permitting at most one fresh planning iteration within the existing budget. Discard the truncated assistant/tool group; missing usage, incomplete streams, exhausted budgets and repeated truncation remain failures. Cancellation and final-synthesis limits still apply.\n- Reject `content_filter` and explicitly incomplete or ambiguous provider termination before executing tools or reporting completion. Filtered or ambiguous responses do not trigger a recovery request; conflicting SSE frames cannot clear an earlier filter.\n- Bind the current real user task across ordinary tool rounds, recovery, thinking-only turns and review, including canonical planning and recall. Resolve the owned task after provider projection, reject lost or ambiguous mappings, and retain the existing hermetic review contract. Recovery hints remain temporary system suffixes and do not replace the task.\n- Preserve legitimate resumed user-message merges through source mappings owned by the built-in role projector, while rejecting forged mapping fields and arbitrary rewrites. Recheck the task after asynchronous recall so changed content or moved messages cannot acquire a stale binding; keep authenticated history unchanged.\n- Move the existing user message after retained read context without duplicating it or discarding metadata. This preserves task identity after canonical compaction and independent CLI restart, retains historical user messages, and does not invent a fallback task when no user is present.\n- Add protocol and real canonical CLI process regressions for recovery, repeated truncation, missing usage, filtered output and ambiguous termination. Separately install three assisted pagination/history regression deliveries; their independent checks do not change the original 34/45 automatic task result.\n- Repair the VS Code README's current-public and unpublished-candidate sections against the existing Marketplace overview contract, retaining versioned artifacts and historical releases.\n- Pair the candidate with Open VSX 0.37.170 / JetBrains 0.4.187 after CLI publication is verified; Context/Memory Kernel remains 0.1.11. Exact-source full multi-OS gates, OIDC publication and public readback are required. Microsoft Marketplace remains deferred.\n- This change does not bypass the diagnostic broker's HTTP403 rejection or guarantee that a model will produce smaller writes. Real-model task retests follow verified publication of the new versions."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.131",

package/src/lib/context-memory-kernel/message-adapter.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import {
   canonicalDigest,
   canonicalJson,
@@ -205,6 +206,17 @@ export function messagesToContextItems(messagesInput, options = {}) {
     ? [...options.allowedSinks]
     : DEFAULT_ALLOWED_SINKS;
   const items = [];
+  const requiredUser = options.requiredUserMessage;
+  if (
+    requiredUser != null &&
+    (!Number.isSafeInteger(requiredUser.index) ||
+      requiredUser.index < 0 ||
+      requiredUser.index >= messages.length ||
+      requiredUser.message?.role !== "user" ||
+      !isDeepStrictEqual(messages[requiredUser.index], requiredUser.message))
+  ) {
+    throw new TypeError("Invalid current-user task binding");
+  }
   const trustedSystemIndexes = new Set(
     Array.isArray(options.trustedSystemIndexes)
       ? options.trustedSystemIndexes.filter(Number.isSafeInteger)
@@ -289,11 +301,20 @@ export function messagesToContextItems(messagesInput, options = {}) {
   const lastIndex = items.findLastIndex(
     (item) => item.kind !== "system-policy",
   );
-  const last = items[lastIndex];
-  if (last) {
-    const payload = JSON.parse(loadBundleContent(last, sessionId));
-    if (payload.messages.at(-1)?.role === "user") {
-      const protectedItem = { ...last };
+  for (let index = 0; index < items.length; index++) {
+    const item = items[index];
+    if (
+      index !== lastIndex &&
+      item.sourceRef.eventSequence !== requiredUser?.index
+    )
+      continue;
+    const payload = JSON.parse(loadBundleContent(item, sessionId));
+    if (
+      payload.messages.at(-1)?.role === "user" &&
+      (index === lastIndex ||
+        item.sourceRef.eventSequence === requiredUser?.index)
+    ) {
+      const protectedItem = { ...item };
       delete protectedItem.digest;
       protectedItem.kind = "task-state";
       protectedItem.priority = 900_000;
@@ -301,7 +322,7 @@ export function messagesToContextItems(messagesInput, options = {}) {
         taskState: "waiting",
         requiredForRecovery: true,
       };
-      items[lastIndex] = normalizeContextItem(protectedItem);
+      items[index] = normalizeContextItem(protectedItem);
     }
   }
   return items;

package/src/lib/context-memory-kernel/provider-context.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import {
   canonicalDigest,
   canonicalJson,
@@ -203,6 +204,40 @@ export async function prepareCanonicalProviderContext(
     };
   }
 
+  // Resolve against the final provider projection, never a pre-projection index.
+  // Exact role/content/metadata matching prevents a transformed tool result or
+  // an ambiguous duplicate from taking the original user's task-state binding.
+  const taskBinding = options.contextMemoryRequiredUserBinding;
+  const requiredUserMessage = taskBinding?.message;
+  function resolveRequiredUserIndex() {
+    if (requiredUserMessage == null) return null;
+    const identities = messages.flatMap((message, index) =>
+      message === taskBinding.original ? [index] : [],
+    );
+    const candidates = identities.length
+      ? identities
+      : taskBinding.allowContentRelocation === true
+        ? messages.map((_, index) => index)
+        : [];
+    const matches = candidates.filter((index) => {
+      const message = messages[index];
+      return (
+        message?.role === "user" &&
+        requiredUserMessage.role === "user" &&
+        isDeepStrictEqual(message, requiredUserMessage)
+      );
+    });
+    if (matches.length !== 1 || identities.length > 1) {
+      const error = new Error(
+        "The current user task was lost, changed or duplicated in provider context",
+      );
+      error.code = "CC_AGENT_TASK_CONTEXT_LOST";
+      throw error;
+    }
+    return matches[0];
+  }
+  let requiredUserIndex = resolveRequiredUserIndex();
+
   // Review can exclude recalled author/session data while retaining the exact
   // canonical context, tool and output-token planning boundary.
   const recallEnabled = options.contextMemoryRecall !== false;
@@ -211,9 +246,9 @@ export async function prepareCanonicalProviderContext(
     : null;
   const sink = String(options.contextMemorySink || `provider.${provider}`);
   const scopeAdmissions = defaultAdmissions(sessionId, options);
-  const lastUser = [...messages]
-    .reverse()
-    .find((message) => message?.role === "user");
+  const lastUser =
+    requiredUserMessage ||
+    [...messages].reverse().find((message) => message?.role === "user");
   const query =
     typeof lastUser?.content === "string" && lastUser.content.trim()
       ? lastUser.content.trim().slice(0, 32 * 1024)
@@ -254,6 +289,9 @@ export async function prepareCanonicalProviderContext(
         }),
       };
   options.signal?.throwIfAborted();
+  // Recall awaits host and storage work. Revalidate the captured task and its
+  // current position before image transformation and immutable item creation.
+  requiredUserIndex = resolveRequiredUserIndex();
   const imageTransport = captureContextImageTransport(messages);
   const messageItems = adjustContextImageTokenEstimates(
     messagesToContextItems(imageTransport.messages, {
@@ -261,6 +299,13 @@ export async function prepareCanonicalProviderContext(
       allowedSinks: [sink],
       trustCurrentSystemPolicy: true,
       trustedSystemIndexes: options.contextMemoryTrustedSystemIndexes,
+      requiredUserMessage:
+        requiredUserIndex === null
+          ? null
+          : {
+              index: requiredUserIndex,
+              message: imageTransport.messages[requiredUserIndex],
+            },
       allowExternalization: false,
     }),
     imageTransport.captures,

package/src/runtime/agent-core.js

@@ -1,3 +1,4 @@
+import { projectMessagesWithTaskBinding } from "./message-roles.js";
 import {
   providerFetch,
   requireUnscopedToolExecution,
@@ -28,6 +29,7 @@ import { resolveLlmConnection } from "../lib/llm-connection-resolution.js";
  */
 
 import fs from "fs";
+import { isDeepStrictEqual } from "node:util";
 import { isUtf8 } from "node:buffer";
 import {
   _isNonNegativeSafeInteger,
@@ -272,6 +274,8 @@ import { isMcpRpcError } from "../harness/mcp-client.js";
 import {
   projectCanonicalResumeMessages,
   markRuntimeOnlySessionMessage,
+  isRuntimeOnlySessionMessage,
+  encodePersistedMessage,
 } from "../lib/session-message-provenance.js";
 import { releaseOldLiveSessionResults } from "../lib/session-runtime-retention.js";
 import {
@@ -12748,6 +12752,10 @@ export async function chatWithTools(rawMessages, options) {
     message.tool_calls = providerMessage.tool_calls;
   }
   const out = { message };
+  if (choice.finish_reason != null) {
+    out.finishReason = choice.finish_reason;
+    out.providerTerminationComplete = data.choices.length === 1;
+  }
   const providerReceipt = supportsOpenAIRequestIdentity
     ? _openAIProviderRequestReceipt(response, data, providerRequestId)
     : null;
@@ -14800,6 +14808,30 @@ function permissionDecision(callId, tool, result) {
 }
 
 export async function* agentLoop(messages, options) {
+  // Bind the actual task before compaction, runtime nudges or provider projection.
+  // A new host-admitted user turn starts a new loop and receives its own binding.
+  const currentUserTask = messages.findLast(
+    (message) =>
+      message?.role === "user" && !isRuntimeOnlySessionMessage(message),
+  );
+  const currentUserTaskSnapshot = currentUserTask
+    ? encodePersistedMessage(currentUserTask)
+    : null;
+  const currentUserTaskBinding = currentUserTaskSnapshot
+    ? {
+        message: currentUserTaskSnapshot,
+        original: currentUserTask,
+        allowContentRelocation:
+          messages.filter(
+            (message) =>
+              message?.role === "user" &&
+              isDeepStrictEqual(
+                encodePersistedMessage(message),
+                currentUserTaskSnapshot,
+              ),
+          ).length === 1,
+      }
+    : null;
   if (options.serviceTier != null) {
     resolveModelServiceTier(
       resolveModelCapabilityProfile(options),
@@ -15384,6 +15416,8 @@ export async function* agentLoop(messages, options) {
   // one-shot guard means a model that keeps returning empty turns completes
   // rather than looping forever (the iteration budget is the hard backstop).
   let emptyThinkingReprompted = false;
+  let outputLimitRecoveryUsed = false;
+  let outputLimitRecoveryPending = null;
   let readFileLoopGuard = new ReadFileLoopGuard();
   let remoteReadLoopGuard = new RemoteReadLoopGuard();
   const prActionTask = isPrActionRequest(messages);
@@ -16316,27 +16350,43 @@ export async function* agentLoop(messages, options) {
           index === resultIndex ? { ...result, content } : message,
         );
       } else {
-        // Full compaction can leave only the pinned request. Reiterate that
-        // exact request after the source data, not a replacement objective.
-        const request = requestMessages.findLast(
+        // Full compaction can leave only the pinned request. Move that same
+        // message after the source data, preserving its metadata and identity.
+        const requestIndex = requestMessages.findLastIndex(
           (message) => message.role === "user",
         );
+        const request = requestMessages[requestIndex];
         callMessages = [
-          ...requestMessages,
+          ...requestMessages.filter((_, index) => index !== requestIndex),
           ...readContext.map((content) => ({ role: "assistant", content })),
-          {
-            role: "user",
-            content: request?.content || "Continue the original user task.",
-          },
+          ...(request ? [request] : []),
         ];
       }
     }
     // Role normalization is request-only: durable history remains unchanged
     // for tool settlement and canonical compaction authority comparisons.
+    let projectedUserTaskBinding = currentUserTaskBinding;
     if (typeof options.projectProviderMessages === "function") {
-      callMessages = options.projectProviderMessages(callMessages);
+      const projected = projectMessagesWithTaskBinding(
+        options.projectProviderMessages,
+        callMessages,
+        currentUserTaskBinding,
+      );
+      callMessages = projected.messages;
+      projectedUserTaskBinding = projected.taskBinding;
     }
     const contextMemoryTrustedSystemIndexes = [];
+    if (outputLimitRecoveryPending !== null) {
+      // A synthetic user turn would replace the protected real task under
+      // canonical context pressure. Keep this one-request hint out of history
+      // and explicitly admit it as trusted system policy in the next plan.
+      callMessages = [
+        ...callMessages,
+        { role: "system", content: outputLimitRecoveryPending },
+      ];
+      contextMemoryTrustedSystemIndexes.push(callMessages.length - 1);
+      outputLimitRecoveryPending = null;
+    }
     if (Number.isFinite(budget.limit)) {
       // consume() already charged this dispatch. The current request may still
       // act even when no further provider request remains. Rebuild this hint
@@ -16496,6 +16546,11 @@ export async function* agentLoop(messages, options) {
           contextMemoryToolDefinitions:
             getProviderToolDefinitions(iterationToolOptions),
           contextMemoryTrustedSystemIndexes,
+          // Independent review uses its existing merged requirement journal and
+          // validates every original requirement after planning below.
+          contextMemoryRequiredUserBinding: independentReviewContext?.active
+            ? null
+            : projectedUserTaskBinding,
         },
       );
       if (canonicalProviderContext.plan) {
@@ -16761,6 +16816,78 @@ export async function* agentLoop(messages, options) {
       throw error;
     }
 
+    if (result?.finishReason === "content_filter") {
+      // Usage has settled above. A provider-filtered round is never a complete
+      // answer or an executable tool batch, and must not trigger a fresh call.
+      await _awaitBackgroundUsageSettlement(
+        backgroundSubAgents,
+        backgroundUsageFailureState,
+      );
+      const error = new Error(
+        "The provider filtered this response. No tools from that response were executed; the task remains incomplete.",
+      );
+      error.code = "CC_MODEL_CONTENT_FILTER";
+      throw error;
+    }
+
+    if (
+      result?.providerTerminationComplete === false &&
+      result.finishReason != null &&
+      result.finishReason !== "length"
+    ) {
+      // Explicit ambiguity is not an executable or final provider round.
+      // Keep absent-reason compatibility and the separate length policy.
+      await _awaitBackgroundUsageSettlement(
+        backgroundSubAgents,
+        backgroundUsageFailureState,
+      );
+      const error = new Error(
+        "The provider response has an incomplete or ambiguous termination. No tools from that response were executed; the task remains incomplete.",
+      );
+      error.code = "CC_MODEL_TERMINATION_INCOMPLETE";
+      throw error;
+    }
+
+    if (result?.finishReason === "length") {
+      // Settle the completed physical request above before any decision. Never
+      // execute even syntactically valid calls from an incomplete generation,
+      // and never insert its partial assistant/tool group into canonical history.
+      const canRecover =
+        result.providerTerminationComplete === true &&
+        !msg?._truncated &&
+        _hasCompleteProviderUsage(result.usage) &&
+        !outputLimitRecoveryUsed &&
+        budget.hasRemaining() &&
+        !prInvestigationExhausted &&
+        !inspectionSynthesisRequired;
+      if (!canRecover) {
+        await _awaitBackgroundUsageSettlement(
+          backgroundSubAgents,
+          backgroundUsageFailureState,
+        );
+        const error = new Error(
+          "Model output reached its token limit. No tools from that response were executed; the task remains incomplete.",
+        );
+        error.code = "CC_MODEL_OUTPUT_LIMIT";
+        throw error;
+      }
+      outputLimitRecoveryUsed = true;
+      outputLimitRecoveryPending =
+        "The previous model response reached its output token limit and was discarded. " +
+        "None of its tool calls were executed. Continue from the last confirmed tool results. " +
+        "Produce one small, complete operation per response. For large files, write a minimal " +
+        "complete scaffold first, then use separate small edit_file calls to add sections. " +
+        "Do not resend the entire large file or continue an unfinished JSON fragment. " +
+        "If no tools are needed, give a shorter complete answer.";
+      yield {
+        type: "iteration-warning",
+        message:
+          "Model output was truncated; requesting one smaller complete step within the remaining budget.",
+      };
+      // This is a fresh budgeted iteration with new input, never a transport retry.
+      continue;
+    }
+
     if (!msg) {
       await _awaitBackgroundUsageSettlement(
         backgroundSubAgents,

package/src/runtime/message-roles.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { canonicalJson } from "@chainlesschain/context-memory-kernel";
 
 /**
@@ -119,6 +120,8 @@ export function mergeConsecutiveMessages(messages) {
  * or folding newly added interrupt/feedback turns. Canonical fingerprints also
  * recognize the same retained messages after compaction recreates objects.
  */
+const RESUME_ROLE_PROJECTIONS = new WeakMap();
+
 export function createResumeRoleProjection(messages) {
   const pairs = new Map();
   const pairKey = (left, right) => canonicalJson([left, right]);
@@ -137,20 +140,81 @@ export function createResumeRoleProjection(messages) {
       pairs.set(key, (pairs.get(key) || 0) + 1);
     }
   }
-  return (requestMessages) => {
+  const project = (requestMessages) => {
     const remaining = new Map(pairs);
     const projected = [];
+    const sources = [];
     for (let index = 0; index < requestMessages.length; index++) {
       const message = requestMessages[index];
       const key =
         index > 0 ? pairKey(requestMessages[index - 1], message) : null;
       if (key && remaining.get(key) > 0) {
         const previous = projected.pop();
+        const previousSources = sources.pop();
         projected.push(...mergeConsecutiveMessages([previous, message]));
+        sources.push([...previousSources, index]);
         remaining.set(key, remaining.get(key) - 1);
-      } else projected.push(message);
+      } else {
+        projected.push(message);
+        sources.push([index]);
+      }
     }
-    return projected;
+    return { messages: projected, sources };
+  };
+  const projection = (requestMessages) => project(requestMessages).messages;
+  RESUME_ROLE_PROJECTIONS.set(projection, project);
+  return projection;
+}
+
+/**
+ * Preserve a bound task through this module's exact, captured resume merges.
+ * Arbitrary callbacks, wrappers and forged properties never receive lineage.
+ */
+export function projectMessagesWithTaskBinding(projection, input, taskBinding) {
+  const owned = RESUME_ROLE_PROJECTIONS.get(projection);
+  if (!owned) {
+    return { messages: projection(input), taskBinding };
+  }
+  const projected = owned(input);
+  if (!taskBinding) return { messages: projected.messages, taskBinding };
+  const identities = input.flatMap((message, index) =>
+    message === taskBinding.original ? [index] : [],
+  );
+  const candidates = identities.length
+    ? identities
+    : taskBinding.allowContentRelocation === true
+      ? input.map((_, index) => index)
+      : [];
+  const matches = candidates.filter(
+    (index) =>
+      input[index]?.role === "user" &&
+      isDeepStrictEqual(input[index], taskBinding.message),
+  );
+  // Leave invalid bindings intact so canonical admission rejects them normally.
+  if (matches.length !== 1 || identities.length > 1)
+    return { messages: projected.messages, taskBinding };
+  const sourceIndex = matches[0];
+  const targetIndex = projected.sources.findIndex((group) =>
+    group.includes(sourceIndex),
+  );
+  const target = projected.messages[targetIndex];
+  if (target === input[sourceIndex])
+    return { messages: projected.messages, taskBinding };
+  // A merge may discard right-message metadata. Only bare user content has a
+  // complete preservation proof under the established joinContent contract.
+  if (
+    Object.keys(taskBinding.message).some(
+      (key) => !["role", "content"].includes(key),
+    )
+  )
+    return { messages: projected.messages, taskBinding };
+  return {
+    messages: projected.messages,
+    taskBinding: {
+      message: JSON.parse(canonicalJson(target)),
+      original: target,
+      allowContentRelocation: false,
+    },
   };
 }
 

package/src/runtime/provider-stream-state.js

@@ -291,6 +291,9 @@ export function _openaiCachedTokens(usage) {
 export function _openaiInitState() {
   return {
     responseId: null,
+    finishReason: null,
+    streamDone: false,
+    terminationInvalid: false,
     text: "",
     tools: [],
     inputTokens: null,
@@ -304,13 +307,39 @@ export function _openaiReduceLine(state, raw, onToken) {
   const line = (raw || "").trim();
   if (!line.startsWith("data:")) return state;
   const payload = line.slice(5).trim();
-  if (!payload || payload === "[DONE]") return state;
+  if (!payload) return state;
+  if (payload === "[DONE]") {
+    if (!state.finishReason || state.streamDone)
+      state.terminationInvalid = true;
+    state.streamDone = true;
+    return state;
+  }
   let obj;
   try {
     obj = JSON.parse(payload);
   } catch {
+    state.terminationInvalid = true;
     return state;
   }
+  if (state.streamDone || obj.error) state.terminationInvalid = true;
+  if (!Array.isArray(obj.choices) || obj.choices.length > 1) {
+    state.terminationInvalid = true;
+  }
+  const choice = obj.choices?.[0];
+  if (choice) {
+    if (state.finishReason || (choice.index != null && choice.index !== 0))
+      state.terminationInvalid = true;
+    if (choice.finish_reason != null) {
+      // Terminal filtering cannot be downgraded to stop/tools by a later
+      // conflicting frame. Length likewise remains non-complete.
+      if (
+        state.finishReason !== "content_filter" &&
+        (state.finishReason !== "length" ||
+          choice.finish_reason === "content_filter")
+      )
+        state.finishReason = choice.finish_reason;
+    }
+  }
   if (!state.responseId) state.responseId = _providerReceiptId(obj.id);
   const pricing = projectEnvelopePricingContext(obj.usage || {}, obj);
   for (const [key, value] of Object.entries(pricing)) {
@@ -376,6 +405,11 @@ export function _openaiFinalize(state) {
   const message = { role: "assistant", content: state.text };
   if (toolCalls.length) message.tool_calls = toolCalls;
   const out = { message };
+  if (state.finishReason != null) {
+    out.finishReason = state.finishReason;
+    out.providerTerminationComplete =
+      state.streamDone && !state.terminationInvalid;
+  }
   if (
     state.usageInvalid !== true &&
     _isNonNegativeSafeInteger(state.inputTokens) &&