chainlesschain 0.166.107 → 0.166.108

package/src/lib/session-host-snapshot.js

@@ -27,6 +27,7 @@ import {
   sanitizePersistedMessages,
 } from "./session-message-provenance.js";
 import { createSessionTranscriptStructureProjection } from "./session-transcript-structure.js";
+import { projectToolRoundMessages } from "./session-tool-round.js";
 import { normalizeSessionBudgetRootConfig } from "./session-budget-production-root.js";
 import {
   createDeferredQuestionEventReducer,
@@ -86,6 +87,8 @@ function replayMessagesFromVerifiedEvents(events) {
       isReplayableMessage(event.data)
     ) {
       suffix.push(event.data);
+    } else if (event?.type === "tool_round") {
+      suffix.push(...projectToolRoundMessages(event).toReversed());
     } else if (event?.type === "ws_turn") {
       const turn = projectWsTurnMessages(event);
       if (turn) suffix.push(turn.assistant, turn.user);

package/src/lib/session-message-provenance.js

@@ -26,6 +26,7 @@ export const DURABLE_SYSTEM_MESSAGE_KINDS = Object.freeze({
 
 const DURABLE_KINDS = new Set(Object.values(DURABLE_SYSTEM_MESSAGE_KINDS));
 const RUNTIME_PROVENANCE = new WeakMap();
+const RUNTIME_ONLY_MESSAGES = new WeakSet();
 const INVALID_DATA = Symbol("invalid-session-message-data");
 const MAX_DATA_DEPTH = 100;
 const MAX_DATA_NODES = 100_000;
@@ -227,11 +228,11 @@ function validWireTag(value) {
   const snapshot = plainDataSnapshot(value);
   return Boolean(
     snapshot &&
-    snapshot.keys.length === 2 &&
-    snapshot.keys.includes("schema") &&
-    snapshot.keys.includes("kind") &&
-    dataValue(snapshot, "schema") === SESSION_MESSAGE_PROVENANCE_SCHEMA &&
-    DURABLE_KINDS.has(dataValue(snapshot, "kind")),
+      snapshot.keys.length === 2 &&
+      snapshot.keys.includes("schema") &&
+      snapshot.keys.includes("kind") &&
+      dataValue(snapshot, "schema") === SESSION_MESSAGE_PROVENANCE_SCHEMA &&
+      DURABLE_KINDS.has(dataValue(snapshot, "kind")),
   );
 }
 
@@ -248,6 +249,23 @@ export function markDurableSystemMessage(message, kind) {
   return attachRuntimeTag(message, canonicalTag(kind));
 }
 
+// Only host-created retry/result-delivery messages can be excluded from replay.
+// There is deliberately no wire tag: a provider field or a serialized copy
+// cannot suppress a real user message from authority comparison.
+export function markRuntimeOnlySessionMessage(message) {
+  const snapshot = plainDataSnapshot(message);
+  if (!snapshot || !["user", "assistant"].includes(dataValue(snapshot, "role")))
+    throw new TypeError(
+      "Runtime-only nudges must be user or assistant messages",
+    );
+  RUNTIME_ONLY_MESSAGES.add(message);
+  return message;
+}
+
+export function isRuntimeOnlySessionMessage(message) {
+  return RUNTIME_ONLY_MESSAGES.has(message);
+}
+
 export function getDurableSystemMessageProvenance(message) {
   const snapshot = plainDataSnapshot(message);
   if (!snapshot || dataValue(snapshot, "role") !== "system") return null;
@@ -422,6 +440,7 @@ export function projectCanonicalResumeMessages(messages, options = {}) {
       invalid("Canonical resume message must contain JSON-safe data");
       continue;
     }
+    if (isRuntimeOnlySessionMessage(raw)) continue;
     if (role !== "system") {
       projected.push(clean);
     } else if (runtimeTag) {

package/src/lib/session-tool-round.js

@@ -0,0 +1,39 @@
+/** Append-only, complete provider assistant/tool exchanges. No policy or user
+ * messages may enter durable replay through this event. */
+export const TOOL_ROUND_EVENT = "tool_round";
+export const TOOL_ROUND_SCHEMA = "chainlesschain.session-tool-round/v1";
+
+export function assertCompleteToolRounds(messages) {
+  if (!Array.isArray(messages) || messages.length === 0)
+    throw new TypeError("Tool rounds require a non-empty message array");
+  const pending = new Set();
+  for (const message of messages) {
+    if (message?.role === "assistant" && pending.size === 0) {
+      if (!Array.isArray(message.tool_calls) || message.tool_calls.length === 0)
+        throw new TypeError("Tool round assistant must contain tool calls");
+      for (const call of message.tool_calls) {
+        if (typeof call?.id !== "string" || !call.id || pending.has(call.id))
+          throw new TypeError("Malformed or duplicate tool call");
+        pending.add(call.id);
+      }
+    } else if (
+      message?.role === "tool" &&
+      pending.delete(message.tool_call_id)
+    ) {
+      // Every result settles exactly one call in the immediately preceding round.
+    } else {
+      throw new TypeError(
+        "Tool round contains an orphan result or forbidden message",
+      );
+    }
+  }
+  if (pending.size) throw new TypeError("Tool round is incomplete");
+  return messages;
+}
+
+export function projectToolRoundMessages(event) {
+  if (event?.type !== TOOL_ROUND_EVENT) return null;
+  if (event.data?.schema !== TOOL_ROUND_SCHEMA)
+    throw new TypeError("Unsupported session tool round schema");
+  return assertCompleteToolRounds(event.data.messages);
+}

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

@@ -11,6 +11,7 @@ import {
 } from "./session-transcript-page.js";
 import { createSessionHistoryOrigins } from "./session-history-origins.js";
 import { getDurableSystemMessageProvenance } from "./session-message-provenance.js";
+import { projectToolRoundMessages } from "./session-tool-round.js";
 import {
   BRANCH_HISTORY_SCHEMA,
   BRANCH_HISTORY_SYSTEM_ORIGINS_SCHEMA,
@@ -29,6 +30,7 @@ const MAX_HISTORY_RANGES = 16384;
 // Enumerate all possible display sources, including replacement snapshots.
 // Their physical sequence never changes when the selected history rewinds.
 function eventMessages(event, imported = null) {
+  if (event.type === "tool_round") return projectToolRoundMessages(event);
   if (event.type === BRANCH_HISTORY_MESSAGE)
     return imported?.kind === "archive" ? [imported.message] : [];
   if (

package/src/lib/session-transcript-page.js

@@ -1,3 +1,4 @@
+import { projectToolRoundMessages } from "./session-tool-round.js";
 import { createHash } from "node:crypto";
 import {
   readVerifiedProjection,
@@ -120,7 +121,9 @@ export function createSessionTranscriptPageProjection(
         ["user_message", "assistant_message", "system"].includes(event.type)
       )
         append(event.data);
-      else if (event.type === "ws_turn") {
+      else if (event.type === "tool_round") {
+        for (const message of projectToolRoundMessages(event)) append(message);
+      } else if (event.type === "ws_turn") {
         const pair = projectWsTurnMessages(event);
         if (pair) {
           append(pair.user);

package/src/lib/session-transcript-structure.js

@@ -1,3 +1,4 @@
+import { projectToolRoundMessages } from "./session-tool-round.js";
 /**
  * Streaming structural authority for canonical session transcripts.
  *
@@ -72,6 +73,9 @@ export function createSessionTranscriptStructureProjection(
 
   return Object.freeze({
     accept(event) {
+      // Unknown versions and malformed/orphan results fail closed at every
+      // verified projection, even if that projection does not display tools.
+      if (event?.type === "tool_round") projectToolRoundMessages(event);
       const index = eventCount;
       eventCount += 1;
       if (event?.type === "session_start") {

package/src/runtime/__tests__/message-roles.test.js

@@ -2,9 +2,38 @@ import { describe, it, expect } from "vitest";
 import {
   mergeConsecutiveMessages,
   collapseConsecutiveMessagesInPlace,
+  createResumeRoleProjection,
   _internal,
 } from "../message-roles.js";
 
+describe("createResumeRoleProjection", () => {
+  it("normalizes retained resume pairs across clones without folding later feedback", () => {
+    const initial = [
+      { role: "system", content: "policy" },
+      { role: "user", content: "unanswered" },
+      { role: "user", content: "resume" },
+    ];
+    const project = createResumeRoleProjection(initial);
+    const request = [
+      ...structuredClone(initial),
+      { role: "assistant", content: "reply" },
+      { role: "user", content: "feedback" },
+      { role: "user", content: "next input" },
+    ];
+    const before = structuredClone(request);
+    const projected = project(request);
+    expect(request).toEqual(before);
+    expect(initial).toHaveLength(3);
+    expect(
+      projected
+        .filter((message) => message.role === "user")
+        .map((message) => message.content),
+    ).toEqual(["unanswered\n\nresume", "feedback", "next input"]);
+    expect(projected.at(-1)).toBe(request.at(-1));
+    expect(project(request)).toEqual(projected);
+  });
+});
+
 describe("mergeConsecutiveMessages", () => {
   it("is a no-op on a healthy alternating transcript", () => {
     const msgs = [

package/src/runtime/agent-core.js

@@ -46,6 +46,7 @@ import {
   buildReadFileOutline,
 } from "../lib/read-file-page.js";
 import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
+const READ_FILE_REQUEST_CONTEXT = Symbol("read-file-request-context");
 import { gitToolInputError } from "../lib/git-tool-input.js";
 import { shellOutputPage, shellOutputPreview } from "../lib/shell-output.js";
 import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "../lib/diagnostic-workflow.js";
@@ -232,7 +233,10 @@ import {
   formatStructuredHandoff,
 } from "../harness/structured-handoff.js";
 import { isMcpRpcError } from "../harness/mcp-client.js";
-import { projectCanonicalResumeMessages } from "../lib/session-message-provenance.js";
+import {
+  projectCanonicalResumeMessages,
+  markRuntimeOnlySessionMessage,
+} from "../lib/session-message-provenance.js";
 import { releaseOldLiveSessionResults } from "../lib/session-runtime-retention.js";
 import {
   pathMatchesOpenedFileIdentitySync,
@@ -4935,7 +4939,19 @@ export async function _withPostEditDiagnostics(
   // Parsing the bytes we just wrote is safe even when starting a language
   // server is forbidden. Feed definite local import mistakes back in the same
   // tool result; a successful write still means persistence, not test success.
-  let enriched = result;
+  let enriched =
+    result?.success === true && typeof writtenContent === "string"
+      ? {
+          ...result,
+          validation: {
+            persisted: true,
+            testsExecuted: false,
+            relativeImports: "not-checked",
+            message:
+              "File saved. This file operation did not run tests. Any import feedback checks explicit JavaScript relative references only and does not establish test or task acceptance.",
+          },
+        }
+      : result;
   if (
     result?.success === true &&
     typeof writtenContent === "string" &&
@@ -4956,9 +4972,21 @@ export async function _withPostEditDiagnostics(
           content: writtenContent,
           workspaceRoot: root,
         });
+        enriched = {
+          ...enriched,
+          validation: {
+            ...enriched.validation,
+            relativeImports: checked.status,
+            checkedReferences: checked.checkedReferences,
+            uncheckedReferences: checked.uncheckedReferences.length,
+            truncated: checked.truncated,
+            diagnosticsTruncated: checked.diagnostics.length > 8,
+            ...(checked.reason ? { skipReason: checked.reason } : {}),
+          },
+        };
         if (checked.diagnostics.length) {
           enriched = {
-            ...result,
+            ...enriched,
             newDiagnostics: [
               ...(result.newDiagnostics || []),
               ...checked.diagnostics.slice(0, 8),
@@ -12103,6 +12131,10 @@ export async function chatWithTools(rawMessages, options) {
     tools = projected.tools;
   }
 
+  if (options[READ_FILE_REQUEST_CONTEXT]) {
+    options[READ_FILE_REQUEST_CONTEXT].messages = messages;
+  }
+
   throwIfAborted(signal);
 
   // Host accounting starts only after request admission. A rejected model
@@ -14697,7 +14729,9 @@ export async function* agentLoop(messages, options) {
     // These tools are alternative ways to deliver content to the same target.
     // A successful explicit replacement must settle a deferred edit (and vice
     // versa); move/delete/notebook effects retain their distinct obligations.
-    const effect = ["write_file", "edit_file", "edit_file_hashed"].includes(tool)
+    const effect = ["write_file", "edit_file", "edit_file_hashed"].includes(
+      tool,
+    )
       ? "file-content"
       : tool;
     const key = JSON.stringify([effect, targets]);
@@ -15850,10 +15884,12 @@ export async function* agentLoop(messages, options) {
             // SubagentStop hooks are best-effort
           }
         }
-        messages.push({
-          role: "user",
-          content: _backgroundSubAgentResultText(entry),
-        });
+        messages.push(
+          markRuntimeOnlySessionMessage({
+            role: "user",
+            content: _backgroundSubAgentResultText(entry),
+          }),
+        );
         taskProgressTracker.retainChildResult(
           entry.id,
           {
@@ -16002,6 +16038,11 @@ export async function* agentLoop(messages, options) {
         ];
       }
     }
+    // Role normalization is request-only: durable history remains unchanged
+    // for tool settlement and canonical compaction authority comparisons.
+    if (typeof options.projectProviderMessages === "function") {
+      callMessages = options.projectProviderMessages(callMessages);
+    }
     const contextMemoryTrustedSystemIndexes = [];
     if (Number.isFinite(budget.limit)) {
       // consume() already charged this dispatch. The current request may still
@@ -16197,10 +16238,15 @@ export async function* agentLoop(messages, options) {
     const requestOptions = providerRequestId
       ? { ...plannedProviderOptions, providerRequestId }
       : plannedProviderOptions;
-    const providerCallOptions =
-      evolutionIngress !== null
+    // Capture the custom adapter's input or the built-in adapter's final
+    // projection. Commit visibility only after a successful model response.
+    const readFileRequestContext = { messages: callMessages };
+    const providerCallOptions = {
+      [READ_FILE_REQUEST_CONTEXT]: readFileRequestContext,
+      ...(evolutionIngress !== null
         ? { ...requestOptions, evolutionIngress }
-        : requestOptions;
+        : requestOptions),
+    };
     const modelUsageCall = {
       type: "model-usage-started",
       callId: _newModelUsageCallId("model"),
@@ -16302,6 +16348,7 @@ export async function* agentLoop(messages, options) {
         },
         "model_error",
       );
+      readFileLoopGuard.observeVisibleMessages(readFileRequestContext.messages);
       providerReceipt = providerRequestId
         ? _snapshotProviderRequestReceipt(
             result?.providerReceipt,
@@ -16463,17 +16510,24 @@ export async function* agentLoop(messages, options) {
         );
         _throwBackgroundUsageFailureState(backgroundUsageFailureState);
         throwIfAborted(signal);
-        messages.push({ role: "assistant", content: msg.content || "" });
+        messages.push(
+          markRuntimeOnlySessionMessage({
+            role: "assistant",
+            content: msg.content || "",
+          }),
+        );
         for (const entry of _takeSettledBackgroundSubAgents(
           backgroundSubAgents,
         )) {
           _throwBackgroundSubAgentUsageFailure(entry);
-          messages.push({
-            role: "user",
-            content:
-              _backgroundSubAgentResultText(entry) +
-              "\n\nAll background sub-agents have finished. Incorporate their results and give your final answer.",
-          });
+          messages.push(
+            markRuntimeOnlySessionMessage({
+              role: "user",
+              content:
+                _backgroundSubAgentResultText(entry) +
+                "\n\nAll background sub-agents have finished. Incorporate their results and give your final answer.",
+            }),
+          );
           taskProgressTracker.retainChildResult(
             entry.id,
             {
@@ -16498,17 +16552,24 @@ export async function* agentLoop(messages, options) {
         const pending = [...pendingSubtreeMutations.values()];
         if (!subtreeMutationReprompted && budget.remaining() > 0) {
           subtreeMutationReprompted = true;
-          messages.push({ role: "assistant", content: msg.content || "" });
-          messages.push({
-            role: "user",
-            content:
-              "Runtime status: these mutations were deferred before any effect: " +
-              JSON.stringify(pending) +
-              ". Review the authoritative subtree instructions already returned. " +
-              "If still authorized and appropriate, explicitly issue the required tool call. " +
-              "Do not bypass rules or perform a prohibited write. Otherwise report the unfinished work and its blocker. " +
-              "A promise to retry does not execute the mutation.",
-          });
+          messages.push(
+            markRuntimeOnlySessionMessage({
+              role: "assistant",
+              content: msg.content || "",
+            }),
+          );
+          messages.push(
+            markRuntimeOnlySessionMessage({
+              role: "user",
+              content:
+                "Runtime status: these mutations were deferred before any effect: " +
+                JSON.stringify(pending) +
+                ". Review the authoritative subtree instructions already returned. " +
+                "If still authorized and appropriate, explicitly issue the required tool call. " +
+                "Do not bypass rules or perform a prohibited write. Otherwise report the unfinished work and its blocker. " +
+                "A promise to retry does not execute the mutation.",
+            }),
+          );
           yield {
             type: "iteration-warning",
             message:
@@ -16551,13 +16612,17 @@ export async function* agentLoop(messages, options) {
       const _contentEmpty = !String(msg.content || "").trim();
       if (_contentEmpty && _thinking && !emptyThinkingReprompted) {
         emptyThinkingReprompted = true;
-        messages.push({ role: "assistant", content: "" });
-        messages.push({
-          role: "user",
-          content:
-            "You ended your turn with only internal reasoning and no visible " +
-            "response. Please provide your actual answer now.",
-        });
+        messages.push(
+          markRuntimeOnlySessionMessage({ role: "assistant", content: "" }),
+        );
+        messages.push(
+          markRuntimeOnlySessionMessage({
+            role: "user",
+            content:
+              "You ended your turn with only internal reasoning and no visible " +
+              "response. Please provide your actual answer now.",
+          }),
+        );
         yield { type: "empty-thinking-reprompt", runId };
         continue;
       }
@@ -16614,13 +16679,20 @@ export async function* agentLoop(messages, options) {
         }
         if (stopOutcome && stopOutcome.decision === "block") {
           stopHookActive = true;
-          messages.push({ role: "assistant", content: msg.content || "" });
-          messages.push({
-            role: "user",
-            content:
-              stopOutcome.reason ||
-              "A Stop hook requested that you keep working.",
-          });
+          messages.push(
+            markRuntimeOnlySessionMessage({
+              role: "assistant",
+              content: msg.content || "",
+            }),
+          );
+          messages.push(
+            markRuntimeOnlySessionMessage({
+              role: "user",
+              content:
+                stopOutcome.reason ||
+                "A Stop hook requested that you keep working.",
+            }),
+          );
           yield {
             type: "stop-hook-continue",
             runId,