chainlesschain 0.166.131 → 0.166.133

package/src/runtime/agent-core.js

@@ -1,3 +1,4 @@
+import { projectMessagesWithTaskBinding } from "./message-roles.js";
 import {
   providerFetch,
   requireUnscopedToolExecution,
@@ -9,7 +10,10 @@ import {
   normalizeProviderBaseUrl,
   openAICompatibleBaseUrl,
 } from "../lib/provider-protocol.js";
-import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import {
+  BUILT_IN_PROVIDERS,
+  resolveProviderDefinition,
+} from "../lib/llm-providers.js";
 import { resolveLlmConnection } from "../lib/llm-connection-resolution.js";
 /**
  * Agent Core — transport-independent agentic logic
@@ -28,6 +32,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 +277,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 {
@@ -12118,11 +12125,65 @@ function getEffectiveToolDefinitions(options = {}) {
   });
 }
 
+function projectExactFileMutationToolSchemas(
+  definitions,
+  scope,
+  externalToolExecutors,
+) {
+  if (scope == null) return definitions;
+  return definitions.map((tool) => {
+    const name = tool?.function?.name;
+    if (
+      !["write_file", "edit_file", "edit_file_hashed"].includes(name) ||
+      !AGENT_TOOLS.includes(tool) ||
+      externalToolExecutors?.[name]
+    ) {
+      return tool;
+    }
+    const parameters = tool.function.parameters;
+    return {
+      ...tool,
+      function: {
+        ...tool.function,
+        parameters: {
+          ...parameters,
+          properties: {
+            ...parameters.properties,
+            path: {
+              ...parameters.properties.path,
+              // Complete host-authorized set: never truncate this enum or
+              // derive it from a read result. Normal tool context budgeting
+              // sees the same schema that is sent to the provider.
+              enum: [...scope.allowedPaths],
+              description:
+                "Use exactly one listed canonical repo-relative path. Read tools may return absolute paths; those are not valid mutation arguments in this run. Do not use an absolute path, ./ prefix, .. segment or backslash. This schema is guidance; all execution-time permission and file-identity checks still apply.",
+            },
+          },
+        },
+      },
+    };
+  });
+}
+
 function getProviderToolDefinitions(options = {}) {
-  return projectMcpToolDefinitions(
+  const definitions = projectMcpToolDefinitions(
     getEffectiveToolDefinitions(options),
     options.externalToolExecutors,
   );
+  if (options.fileMutationScope == null) return definitions;
+  if (options.exactToolNames !== true || options.hermeticExecution !== true) {
+    throw new Error(
+      "exact file mutation scope requires exactToolNames=true and hermeticExecution=true",
+    );
+  }
+  const scope = normalizeExactFileMutationScope(options.fileMutationScope, {
+    cwd: options.cwd || process.cwd(),
+  });
+  return projectExactFileMutationToolSchemas(
+    definitions,
+    scope,
+    options.externalToolExecutors,
+  );
 }
 
 const PROVIDER_REQUEST_ID_RE = /^[\x21-\x7e]{1,512}$/;
@@ -12536,7 +12597,7 @@ export async function chatWithTools(rawMessages, options) {
   }
 
   // OpenAI-compatible providers
-  const providerDefinition = BUILT_IN_PROVIDERS[provider];
+  const providerDefinition = resolveProviderDefinition(provider);
   const url = openAICompatibleBaseUrl(provider, baseUrl);
 
   if (!providerDefinition || !url) {
@@ -12551,7 +12612,8 @@ export async function chatWithTools(rawMessages, options) {
 
   const envKey = providerDefinition.apiKeyEnv;
   const key = apiKey;
-  if (!key) throw new Error(`${envKey} required for provider ${provider}`);
+  if (!key && provider !== "custom")
+    throw new Error(`${envKey} required for provider ${provider}`);
   const effectiveModel = model || providerDefinition.models?.[0];
   const modelProfile = resolveModelCapabilityProfile({
     provider,
@@ -12691,7 +12753,7 @@ export async function chatWithTools(rawMessages, options) {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${key}`,
+      ...(key ? { Authorization: `Bearer ${key}` } : {}),
       ...(supportsOpenAIRequestIdentity && providerRequestId
         ? { "X-Client-Request-Id": providerRequestId }
         : {}),
@@ -12748,6 +12810,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;
@@ -13307,7 +13373,7 @@ async function _chatOpenAIStreaming(
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
       ...(providerRequestId
         ? { "X-Client-Request-Id": providerRequestId }
         : {}),
@@ -14800,6 +14866,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),
@@ -14986,6 +15076,7 @@ export async function* agentLoop(messages, options) {
   let effectiveToolOptions = hermeticExecution
     ? {
         ...options,
+        fileMutationScope,
         hostManagedToolPolicy: null,
         hostManagedToolPolicyAuthority: null,
         extraToolDefinitions: [],
@@ -15384,6 +15475,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 +16409,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 +16605,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 +16875,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) &&