@sema-agent/core 7.37.0 → 7.37.1

package/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 7.37.1 — 2026-10-01
+
+**Hard-breaking changes:** none.
+
+**Closed sets.** `ENGINE_NOTICE_CODES` / `EngineNoticeCode` (#1224): +`context.tool_turn_repaired` (audience `operator` in `NOTICE_AUDIENCE`); its `detail.repairs[].form` words are `trailing_text` / `late_result` / `missing_result` / `duplicate_result` (not a package export).
+
+**Package exports:** +0 / −0.
+
+### A session with a broken tool turn heals on its next request: every provider request holds the tool-turn law, once for the three lanes (#1224; behavior (the request view) + closed set +1 notice code; +0 exports) (@server @cli @client-core @test)
+
+- **Before (v7.37.0).** Each brain replayed an assistant's blocks in stored order and merged only ADJACENT tool results into the message after its calls. A stored turn whose calls are followed by another block (the drop note of #1225: [thinking, text, toolCall×2, text]), a result recorded behind a later user or wake message, a call with no result, or two results for one call went to the provider as stored. The Anthropic Messages lane answered 400 `tool_use ids were found without tool_result blocks immediately after`, naming the same id on every later request, so the session could not continue; the two OpenAI-shaped lanes rejected the late / missing / doubled shapes the same way. The acquire reconcile writes the same late shape itself: it closes an orphan call at the transcript's TAIL, behind any later user message.
+- **Now.** The harness's provider-boundary conversion applies one law (`src/engine/llm/tool-turns.ts`) to every request, whichever brain reads it: for every assistant message with calls, (i) the calls are a contiguous tail — every block that is not a call and stands after the first call (between two calls or after the last) moves ahead of the calls, order kept; blocks ahead of the first call, thinking first, keep their place; (ii) the messages right after it are exactly one result per call — a result recorded later moves into the batch (and is not sent again where it was), a second recorded result for the same call is folded into the first (no recorded result is withheld — a withheld result would also make the request lossy for a compaction fork), an interrupted close (the reconcile family's `details.errorKind`) stands in only for a call with no other result (beside a recorded result it is left out), a call with none is closed with the reconcile family's interrupted result (`interruptedResults`, the reconcile family's text and `errorKind` (without its tool-effect refinement — see below); one mint for both). A result answers the NEAREST EARLIER message that emitted its id, — the persisted reconcile's own positional reading, so the two agree on which occurrence a result answers: an earlier use of a reused id with no result before the next use is closed as interrupted, never handed a later use's success, and every result recorded after the last use is that use's. The public `runSideQuery` holds the same law on its caller-supplied history (a host can hand it a stored transcript; an entry's `details` is kept so an interrupted close is recognized; no notice — a side query has no run). The transcript is never rewritten; a legal request list is handed on as the same array. One notice per run per (form, calls): `context.tool_turn_repaired`, `detail: { repairs: [{ form, toolCallIds }], sessionId, runId }`. A result's tool name is NOT an attribution key: the owner is the nearest earlier site that emitted the id, the reconcile family's positional reading and nothing else (the review's two rounds found every name-based reading — the first tree's, and a bounded one — reaching back past a turn the model had already answered and moving its outcome, closing the later call as interrupted). An id reused by another tool before its result is recorded therefore reads positionally, as the reconcile reads it. The repair notice keys a call SET (ids sorted), so one batch read in two orders announces once. The synthesized close is the reconcile family's function with no tool-effect refinement (the view has no effect table), so a read-class tool's close carries the general wording where the persisted reconcile writes the read-class one; and the notice's sentence names a shape "a provider lane rejects" — the OpenAI lanes serialize an assistant's text and calls separately, so a trailing block is announced there but never reached their wire.
+- **Across lanes.** A turn stored by one lane and replayed on another is repaired at the same place: an OpenAI-lane turn [unsigned thinking, text, toolCall×2, note] replayed on the Anthropic lane (the unsigned thinking is not replayed there) goes out as [text, note, tool_use×2].
+- **Who is hurt.** A consumer with a closed table of notice codes (+1 row). A host `Brain` now receives the repaired order for a broken turn, not the stored one — on the run path and in `runSideQuery`.
+- **Known limits.** Two calls sharing an id AND a tool name, the first one's result recorded after the second: it is read as the second's (folded with the second's own, when both were recorded), and the first is closed as interrupted (outcome unknown) — the view cannot tell the two uses apart without an occurrence identity, and it never states a success for the earlier one. Two calls with the SAME id inside one response (admission accepts it; the engine keys a call by its id throughout) go out as two calls with one folded result. The per-message aggregate tool-result budget is measured on the stored batches before the view is built: a batch completed by a moved or folded result can exceed it (the request's total size is unchanged, and the context guard measured it). The acquire reconcile's orphan rule is positional, not name-aware: with an id reused by a later turn it can persist an interrupted close for a call that has a result (the view voids that close; the persisted row is unchanged).
+- **Compensation.** Add the notice row (`operator`). Nothing else moves: a transcript that already has the structure produces the same request as before.
+- Pins: `test/backlog1224-tool-turn-invariants.test.ts` — the user's stored turn through a real Runner on each lane (two requests, both legal, one notice, the transcript unchanged); the sandwich [text, call, text, call] and the lane switch on the Anthropic lane; a late result (6 calls · 5 results · user · 1 result); the reconcile's tail close; a doubled result (folded, both texts sent); a late result crossing a later turn that reuses its id for another tool; a missing result (harness boundary over each real brain); a legal transcript (same array, no notice); the durable-park path (one call of a six-call batch parks, restart, the person types, deny on resume: every request legal, no repair — v7.36.0 the same); an id reused with the same tool, the result recorded after the second use (the first use closed as interrupted, never handed that success); `runSideQuery` over a stored broken turn on each lane; a result whose tool-supplied `details` throws on read (a recorded result, not a close; the view never throws); the law's attribution and mint cells; the seat's per-run dedup. Baseline (the boundary law taken out): 15 of the first 26 red (the sandwich and lane-switch cells, added later, are red under D1019). Mutations D1019 / D1021: `.gate-logs/criteria-7.37.1-mutations.md`.
+
+### A turn's drop notes ride ahead of its tool calls (#1225; behavior (block order); +0 exports) (@server @cli @test)
+
+- **Before (v7.37.0).** When a turn dropped a call (arguments cut mid-JSON, no tool name) or unparseable stream frames, the three brains pushed the `[note: …]` text block at the END of the final content, after the surviving tool calls — the persisted assistant read [thinking, text, toolCall…, note], the shape #1224 describes.
+- **Now.** The notes are placed before the first tool call, in order (`placeTurnNotes`, one helper for the three finalizers); a turn with no call keeps them at the end. The note text is unchanged.
+- **Who is hurt.** A reader of an assistant message's block order on a partial-batch turn (a renderer that showed the note after the calls now shows it before them).
+- **Compensation.** None needed — the text is unchanged, and #1224 repairs turns stored before this release.
+- **The silent cause.** One unparseable frame on an otherwise clean tool turn (every call complete, a normal stop) is a `toolUse` turn with no `errorMessage`: the note was its only trace, and it alone produced the rejected order.
+- Pins: `test/backlog1224-note-placement.test.ts` — three lanes × three causes, an Anthropic request built from such a turn (the brain called directly) ends its assistant on `tool_use`, and the silent dropped-frame turn on each lane. v7.36.0 brains: 15 of 15 red. Mutation D1020.
+
+### A dropped call's message names the output cap only when the cap cut it (#1227; behavior (message text); +0 exports) (@server @cli @test)
+
+- **Before (v7.37.0).** The anthropic and openai lanes appended `; request output cap in effect: N tokens — a cut mid-arguments commonly means the cap was hit` to the `not valid JSON` message whenever a cap was on the wire — also when the stream ended without a stop frame after a few dozen tokens (the field reading: a torn stream, reported as a 64000-token cap), and on a normal `tool_use` / `tool_calls` stop.
+- **Now.** One rule (`truncationCauseClause`, `src/brain/stream-shared.ts`): the cap is named on the lane's cap stop (`max_tokens` / `length`) or when the counted output reached the cap; a stream with no stop frame reads `; the stream ended before its stop frame — the connection closed mid-response`; any other stop adds nothing. The open-responses lane never carried the clause.
+- **Who is hurt.** A reader matching the cap sentence on a message whose stream the cap did not cut.
+- **Compensation.** None needed — the cap-stop message is byte-identical.
+- Pins: `test/backlog1224-note-placement.test.ts` (7 cells; v7.36.0: the 4 normal-stop and torn cells red); `test/brain-unnamed-tool-use-disclosure.test.ts` — the cap-armed cell re-pinned on `finish_reason: "length"` (it asserted the clause on a `tool_calls` stop, the shape retired here). Mutation D1022.
+
 ## 7.37.0 — 2026-10-01
 
 **Closed sets, one by one.**

package/dist/brain/anthropic.js

@@ -2,7 +2,7 @@ import {} from "../internal/llm.js";
 import { BrainError } from "./errors.js";
 import { startsWithInputTooLongAnchor } from "./input-too-long.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { STREAM_TORN_WARNING, createRepetitionPoll, noteResponseModel, parseStreamedToolArgs } from "./stream-shared.js";
+import { STREAM_TORN_WARNING, createRepetitionPoll, noteResponseModel, parseStreamedToolArgs, placeTurnNotes, truncationCauseClause } from "./stream-shared.js";
 import { admitToolCallId, providerResultIds, providerToolCallId } from "./tool-call-id.js";
 import { emitBrainTelemetry, reportReasoningWireFacts } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, modelSupportsVision, sendableImages } from "./media-degrade.js";
@@ -616,30 +616,23 @@ export function createAnthropicBrain(config = {}) {
                         const noUsableContent = toolCalls.length === 0 && !anyText;
                         const toolErrorParts = [];
                         if (malformed.length > 0) {
-                            toolErrorParts.push(`tool call argument(s) not valid JSON (likely truncated, stop_reason="${stopReason ?? "?"}"${sentMaxTokens !== undefined ? `; request output cap in effect: ${sentMaxTokens} tokens — a cut mid-arguments commonly means the cap was hit` : ""}): ${malformed.join("; ")}`);
+                            toolErrorParts.push(`tool call argument(s) not valid JSON (likely truncated, stop_reason="${stopReason ?? "?"}"${truncationCauseClause({ capStop: stopReason === "max_tokens", outputTokens: usageRaw.output_tokens, capTokens: sentMaxTokens, terminalFrameSeen: terminalFrameSeen() })}): ${malformed.join("; ")}`);
                         }
                         if (unnamed.length > 0) {
                             toolErrorParts.push(`tool call(s) arrived with no tool name and cannot be executed (stop_reason="${stopReason ?? "?"}"): ${unnamed.join("; ")}`);
                         }
                         const toolError = toolErrorParts.length > 0 ? toolErrorParts.join(" | ") : undefined;
+                        const notes = [];
                         if (malformed.length > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${malformed.length} tool call(s) were truncated (stop_reason="${stopReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
-                            });
+                            notes.push(`\n[note: ${malformed.length} tool call(s) were truncated (stop_reason="${stopReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`);
                         }
                         if (unnamed.length > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`,
-                            });
+                            notes.push(`\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`);
                         }
                         if (malformedFrames > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
-                            });
+                            notes.push(`\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`);
                         }
+                        placeTurnNotes(finalContent, notes);
                         const truncatedEmpty = stopReason === "max_tokens" && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const staticReasoningCut = truncatedEmpty && !dynamicCut && reasoningSeen && options?.staticReasoningCutDowngrade === true;

package/dist/brain/open-responses.js

@@ -1,7 +1,7 @@
 import {} from "../internal/llm.js";
 import { BrainError } from "./errors.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { STREAM_TORN_WARNING, createRepetitionPoll, noteResponseModel, parseStreamedToolArgs } from "./stream-shared.js";
+import { STREAM_TORN_WARNING, createRepetitionPoll, noteResponseModel, parseStreamedToolArgs, placeTurnNotes } from "./stream-shared.js";
 import { admitToolCallId, providerResultIds, providerToolCallId } from "./tool-call-id.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
@@ -673,24 +673,17 @@ export function createOpenResponsesBrain(config = {}) {
                             toolErrorParts.push(`tool call(s) arrived with no tool name and cannot be executed (status="${terminalLabel}"): ${unnamed.join("; ")}`);
                         }
                         const toolError = toolErrorParts.length > 0 ? toolErrorParts.join(" | ") : undefined;
+                        const notes = [];
                         if (malformed.length > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${malformed.length} tool call(s) were truncated (status="${terminalLabel}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
-                            });
+                            notes.push(`\n[note: ${malformed.length} tool call(s) were truncated (status="${terminalLabel}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`);
                         }
                         if (unnamed.length > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`,
-                            });
+                            notes.push(`\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`);
                         }
                         if (malformedFrames > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
-                            });
+                            notes.push(`\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`);
                         }
+                        placeTurnNotes(finalContent, notes);
                         const truncated = incompleteReason === INCOMPLETE_MAX_OUTPUT_TOKENS;
                         const truncatedEmpty = truncated && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;

package/dist/brain/openai.js

@@ -1,7 +1,7 @@
 import {} from "../internal/llm.js";
 import { repairTextToolCalls } from "./tool-call-repair.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { STREAM_TORN_WARNING, createRepetitionPoll, noteResponseModel, parseStreamedToolArgs } from "./stream-shared.js";
+import { STREAM_TORN_WARNING, createRepetitionPoll, noteResponseModel, parseStreamedToolArgs, placeTurnNotes, truncationCauseClause } from "./stream-shared.js";
 import { admitToolCallId, providerResultIds, providerToolCallId } from "./tool-call-id.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
@@ -570,31 +570,24 @@ export function createOpenAIBrain(config = {}) {
                         }
                         const toolErrorParts = [];
                         if (malformed.length > 0) {
-                            toolErrorParts.push(`tool call argument(s) not valid JSON (likely truncated, finish_reason="${finishReason ?? "?"}"${sentMaxTokens !== undefined ? `; request output cap in effect: ${sentMaxTokens} tokens — a cut mid-arguments commonly means the cap was hit` : ""}): ${malformed.join("; ")}`);
+                            toolErrorParts.push(`tool call argument(s) not valid JSON (likely truncated, finish_reason="${finishReason ?? "?"}"${truncationCauseClause({ capStop: finishReason === "length", outputTokens: usageRaw?.completion_tokens, capTokens: sentMaxTokens, terminalFrameSeen: terminalFrameSeen() })}): ${malformed.join("; ")}`);
                         }
                         if (unnamed.length > 0) {
                             toolErrorParts.push(`tool call(s) arrived with no tool name and cannot be executed (finish_reason="${finishReason ?? "?"}"): ${unnamed.join("; ")}`);
                         }
                         const toolError = toolErrorParts.length > 0 ? toolErrorParts.join(" | ") : undefined;
                         const noUsableContent = toolCalls.length === 0 && !accumText.trim();
+                        const notes = [];
                         if (malformed.length > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
-                            });
+                            notes.push(`\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`);
                         }
                         if (unnamed.length > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`,
-                            });
+                            notes.push(`\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`);
                         }
                         if (malformedFrames > 0) {
-                            finalContent.push({
-                                type: "text",
-                                text: `\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`,
-                            });
+                            notes.push(`\n[note: ${malformedFrames} provider stream frame(s) were not valid JSON and were dropped — the streamed output may be missing content (first sample: ${JSON.stringify(malformedSample)})]`);
                         }
+                        placeTurnNotes(finalContent, notes);
                         const truncatedEmpty = finishReason === "length" && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const safetyCut = finishReason === "content_filter";

package/dist/brain/stream-shared.d.ts

@@ -1,4 +1,5 @@
 import { type RepetitionEvent } from "./repetition.js";
+import type { AssistantMessage } from "../internal/llm.js";
 /**
  * design/157 A10 — stream-parser pieces that the anthropic and openai SSE lanes carried BYTE-IDENTICALLY
  * (verified by diff at 1469481: a 16-line repetition-telemetry closure). Provider-agnostic policy, so it
@@ -28,6 +29,26 @@ import { type RepetitionEvent } from "./repetition.js";
  *  mid-stream promotion (the body threw) and by the parsers' own finalize (content arrived, no finish frame). */
 export declare const STREAM_TORN_WARNING = "Connection closed mid-response. The response above may be incomplete.";
 export declare function parseStreamedToolArgs(json: string): Record<string, unknown> | undefined;
+/**
+ * Place a turn's engine notes in its final content: AHEAD of the first tool call, in order, or at the end of a turn
+ * that has none. Every dropped call (cut arguments, no tool name) and dropped stream frames are stated so the model
+ * re-issues them — also when text survived and no call did; a partial batch still executes its valid calls (a brain
+ * `error` is a terminal task failure, not a re-prompt). No block may follow the calls: the Anthropic Messages API
+ * rejects a `tool_use` followed by anything but another `tool_use`. One rule for the three lanes.
+ */
+export declare function placeTurnNotes(content: AssistantMessage["content"], notes: readonly string[]): void;
+/**
+ * The cause clause of a dropped call's "not valid JSON" message. The output cap is named only when the stream says
+ * the cap cut it — the lane's own cap stop, or a counted output at or over the cap on the wire; a stream that ended
+ * without its stop frame names the transport instead; any other stop adds nothing (naming the cap there sent a reader
+ * after a budget that was never reached). One rule for the lanes that carry the clause.
+ */
+export declare function truncationCauseClause(facts: {
+    capStop: boolean;
+    outputTokens: number | undefined;
+    capTokens: number | undefined;
+    terminalFrameSeen: boolean;
+}): string;
 /** Repetition telemetry for ONE stream — the cut event plus the allowance-spared hits. */
 export interface RepetitionPoll {
     /** Inspect the accumulated text; returns whether it is degenerate (the caller trips its own cut). */

package/dist/brain/stream-shared.js

@@ -16,6 +16,19 @@ export function parseStreamedToolArgs(json) {
         return undefined;
     return parsed;
 }
+export function placeTurnNotes(content, notes) {
+    if (notes.length === 0)
+        return;
+    const at = content.findIndex((block) => block.type === "toolCall");
+    content.splice(at === -1 ? content.length : at, 0, ...notes.map((text) => ({ type: "text", text })));
+}
+export function truncationCauseClause(facts) {
+    const { capStop, outputTokens, capTokens, terminalFrameSeen } = facts;
+    if (capTokens !== undefined && (capStop || (outputTokens !== undefined && outputTokens >= capTokens))) {
+        return `; request output cap in effect: ${capTokens} tokens — a cut mid-arguments commonly means the cap was hit`;
+    }
+    return terminalFrameSeen ? "" : "; the stream ended before its stop frame — the connection closed mid-response";
+}
 export function createRepetitionPoll() {
     let repCut;
     const repSpared = new Map();

package/dist/core/engine-notice.d.ts

@@ -258,6 +258,15 @@ export interface EngineNotice {
      *    call fact. Audience `operator`; `detail: { toolCallId, rawLength, reason, sessionId, runId }` —
      *    `toolCallId` the engine id, `reason` `"charset"` (a control byte, a space, a non-ASCII unit or `~`) or
      *    `"length"` (admitted characters, over 128); never the raw bytes. Absent ⇒ no call of the run was folded.
+     *  - `"context.tool_turn_repaired"` (#1224) — a provider request was built from a transcript that breaks the
+     *    tool-turn law, and the request view restored it (`engine/llm/tool-turns.ts`; the transcript is never
+     *    rewritten): a block after an assistant's tool calls moved ahead of them (`trailing_text`), a result recorded
+     *    later moved up behind its call (`late_result`), a call with no result closed with the reconcile family's
+     *    interrupted result (`missing_result`), a second result recorded for one call folded into the first
+     *    (`duplicate_result`; an interrupted close beside a recorded result is left out, no recorded result is). Advisory:
+     *    the run proceeds on the repaired request. Audience `operator`; `detail: { repairs: [{ form, toolCallIds }],
+     *    sessionId, runId }`. ONCE PER RUN PER (form, calls) — the same broken turn is repaired on every request of
+     *    the run and announced on the first. Absent ⇒ every request of the run already had the structure.
      *  - `"config.read_face_deployment_clamped"` (#237) — a deployment-wide `readFace: "open"` is not
      *    in force beside a read-only (verifier) mount: it clamps to "roots" without throwing
      *    (stricter-wins; the clamp verdict stands, only its occurrence was undisclosed). Announced

package/dist/core/governance-codes.d.ts

@@ -135,7 +135,7 @@ export type NoticeAudience = "user" | "operator";
  * the union's catalog ({@link EngineNotice.code}). The groups below say only which family a row joins,
  * so the catalog is not written a second time here and the two cannot drift.
  */
-export declare const ENGINE_NOTICE_CODES: readonly ["config.autocompact_window_clamped", "config.env_timeout_discarded", "config.materialize_env_discarded", "config.models_swapped", "config.context_settings_swapped", "config.read_face_swapped", "config.read_face_deployment_clamped", "config.write_face_swapped", "config.write_face_deployment_clamped", "config.tool_model_gate_removed", "config.tool_model_gate_unknown_class", "config.tool_model_gate_env_invalid", "config.artifact_host_invalid", "config.task_root_not_canonical", "config.write_protection_target_view_absent", "config.write_protection_unresolved", "config.execution_env_capability_invalid", "config.tool_card_undeclared", "config.tool_face_undeclared", "config.tool_face_invalid", "config.forward_sink_failed", "config.durable_gate_unavailable", "config.peer_admission_out_of_range", "config.peer_lane_unmounted", "config.secret_env_scrubbed", "config.permission_mode_unavailable", "permission.ask_released_by_mode", "permission.read_deny_unapplied", "permission.rule_store_unavailable", "resume.legacy_mode_seed_migrated", "peer.inbound_disposition", "peer.held_settled", "peer.idle_subscription", "classifier.denial_limit", "classifier.fallback", "classifier.role_defaulted", "classifier.contract_broken", "classifier.unavailable", "checkpoint.execution_outcome_unrecorded", "delegation.transcript_integrity", "delegation.ask_unresolvable", "mcp.injection_dropped", "mcp.revocation_probe_failed", "mcp.server_redialed", "workflow.governance_key_stripped", "workflow.agent_option_ignored", "memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.content_class_declared", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "memory.consolidation_recommended", "memory.consolidation_committed", "memory.consolidation_conflict", "memory.consolidation_incomplete", "memory.consolidation_refused", "memory.consolidation_withheld", "memory.restore_withheld", "memory.project_scope_absent", "route.fallback_to_primary", "route.classifier_unroutable", "route.base_url_changed_key_unchanged", "route.response_model_mismatch", "route.tool_call_id_folded", "task.user_steer_undrained", "task.user_followup_undrained", "steering.parked_input_blocked", "task.turn_interrupted", "task.halt_unconsumed", "task.late_approval", "task.interrupt_unconsumed", "approval.read_root_granted", "approval.read_root_grant_rejected", "memory.capture_opted_out", "memory.capture_optout_unpersisted", "skills.listing_truncated", "agents.listing_truncated", "tool_result.offload_put_failed"];
+export declare const ENGINE_NOTICE_CODES: readonly ["config.autocompact_window_clamped", "config.env_timeout_discarded", "config.materialize_env_discarded", "config.models_swapped", "config.context_settings_swapped", "config.read_face_swapped", "config.read_face_deployment_clamped", "config.write_face_swapped", "config.write_face_deployment_clamped", "config.tool_model_gate_removed", "config.tool_model_gate_unknown_class", "config.tool_model_gate_env_invalid", "config.artifact_host_invalid", "config.task_root_not_canonical", "config.write_protection_target_view_absent", "config.write_protection_unresolved", "config.execution_env_capability_invalid", "config.tool_card_undeclared", "config.tool_face_undeclared", "config.tool_face_invalid", "config.forward_sink_failed", "config.durable_gate_unavailable", "config.peer_admission_out_of_range", "config.peer_lane_unmounted", "config.secret_env_scrubbed", "config.permission_mode_unavailable", "permission.ask_released_by_mode", "permission.read_deny_unapplied", "permission.rule_store_unavailable", "resume.legacy_mode_seed_migrated", "peer.inbound_disposition", "peer.held_settled", "peer.idle_subscription", "classifier.denial_limit", "classifier.fallback", "classifier.role_defaulted", "classifier.contract_broken", "classifier.unavailable", "checkpoint.execution_outcome_unrecorded", "delegation.transcript_integrity", "delegation.ask_unresolvable", "mcp.injection_dropped", "mcp.revocation_probe_failed", "mcp.server_redialed", "workflow.governance_key_stripped", "workflow.agent_option_ignored", "memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.content_class_declared", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "memory.consolidation_recommended", "memory.consolidation_committed", "memory.consolidation_conflict", "memory.consolidation_incomplete", "memory.consolidation_refused", "memory.consolidation_withheld", "memory.restore_withheld", "memory.project_scope_absent", "route.fallback_to_primary", "route.classifier_unroutable", "route.base_url_changed_key_unchanged", "route.response_model_mismatch", "route.tool_call_id_folded", "context.tool_turn_repaired", "task.user_steer_undrained", "task.user_followup_undrained", "steering.parked_input_blocked", "task.turn_interrupted", "task.halt_unconsumed", "task.late_approval", "task.interrupt_unconsumed", "approval.read_root_granted", "approval.read_root_grant_rejected", "memory.capture_opted_out", "memory.capture_optout_unpersisted", "skills.listing_truncated", "agents.listing_truncated", "tool_result.offload_put_failed"];
 /** A code this engine mints (see {@link ENGINE_NOTICE_CODES}). NOT the type of
  *  `EngineNotice.code`, which stays `string` — a host forwarding its own notices through the same
  *  sink is a supported shape, and narrowing that field would break it. */

package/dist/core/governance-codes.js

@@ -179,6 +179,7 @@ export const ENGINE_NOTICE_CODES = [
     "route.base_url_changed_key_unchanged",
     "route.response_model_mismatch",
     "route.tool_call_id_folded",
+    "context.tool_turn_repaired",
     "task.user_steer_undrained",
     "task.user_followup_undrained",
     "steering.parked_input_blocked",
@@ -271,6 +272,7 @@ const NOTICE_AUDIENCE_TABLE = {
     "route.base_url_changed_key_unchanged": "operator",
     "route.response_model_mismatch": "operator",
     "route.tool_call_id_folded": "operator",
+    "context.tool_turn_repaired": "operator",
     "skills.listing_truncated": "operator",
     "agents.listing_truncated": "operator",
     "tool_result.offload_put_failed": "operator",

package/dist/core/runner/run-identity-wiring.d.ts

@@ -12,7 +12,7 @@ export interface RunIdentityWiringInput {
      *  task_notification frames. */
     queue: PushQueue<TaskEvent>;
     /** borrowed-mutable — the leg's prepared seat: the harness sinks (`onUndrainedEngineNotes`, `engineInjectionsHeld`,
-     *  `onUndrainedUserInputs`, `onEngineNoteConsumed`) are installed, `nextTurn` is appended to; the ids, the identity
+     *  `onUndrainedUserInputs`, `onEngineNoteConsumed`, `onToolTurnRepaired`) are installed, `nextTurn` is appended to; the ids, the identity
      *  envelope, the hold refs, the memory session and the listing / roster faces are read. */
     prepared: Prepared;
     /** borrowed-readonly — the trusted run-scoped channel: `parentToolCallId`, `onNotifyInjectorReady`. */

package/dist/core/runner/run-identity-wiring.js

@@ -3,6 +3,7 @@ import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js"
 import { recordFrameReceipt, toolResultReceiptKey } from "../frame-settlement.js";
 import { discloseDroppedPending, renderTaskNotificationXml, taskNotificationDedupKey } from "../task-notification.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
+import { createToolTurnRepairSeat } from "./tool-turn-repair-seat.js";
 export function runIdentityWiring(input) {
     const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, mcpRedialRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, pendingSessionNotifications, runner } = input;
     notificationLane.harness = prepared.harness;
@@ -84,6 +85,7 @@ export function runIdentityWiring(input) {
         if (key !== undefined)
             recordFrameReceipt(seam, key, carrier.kind === "tool_result" ? carrier.content : undefined, entryId);
     };
+    prepared.harness.onToolTurnRepaired = createToolTurnRepairSeat((notice) => runner.deps.onNotice?.(notice), { sessionId: prepared.sessionId, runId: prepared.runId });
     if (notifyRef)
         notifyRef.inject = injectTaskNotification;
     if (captureOptOutRef && prepared.memoryEngineSession?.captureOptOut !== undefined) {

package/dist/core/runner/tool-turn-repair-seat.d.ts

@@ -0,0 +1,8 @@
+import type { EngineNotice } from "../engine-notice.js";
+import type { ToolTurnRepair } from "../../internal/llm.js";
+/** The notice's attribution ids — the same pair, for the same reason, as the fold seat's. */
+export interface ToolTurnRepairSeatIds {
+    sessionId: string;
+    runId: string;
+}
+export declare function createToolTurnRepairSeat(onNotice: ((notice: EngineNotice) => void) | undefined, ids: ToolTurnRepairSeatIds): (repairs: readonly ToolTurnRepair[]) => void;

package/dist/core/runner/tool-turn-repair-seat.js

@@ -0,0 +1,28 @@
+import { deliverEngineNotice } from "../engine-notice.js";
+const FORM_SENTENCE = {
+    trailing_text: "a block after an assistant's tool calls was moved ahead of them",
+    late_result: "a result recorded later was moved up behind its call",
+    missing_result: "a call with no result was closed as interrupted (outcome unknown)",
+    duplicate_result: "a second result recorded for one call was folded into the first (an interrupted close beside a recorded result is left out)",
+};
+export function createToolTurnRepairSeat(onNotice, ids) {
+    const announced = new Set();
+    return (repairs) => {
+        const fresh = repairs.filter((repair) => {
+            const key = `${repair.form}\u0000${[...repair.toolCallIds].sort().join("\u0000")}`;
+            if (announced.has(key))
+                return false;
+            announced.add(key);
+            return true;
+        });
+        if (fresh.length === 0)
+            return;
+        deliverEngineNotice(onNotice, {
+            code: "context.tool_turn_repaired",
+            message: `The session transcript carries ${fresh.length === 1 ? "a tool turn" : `${fresh.length} tool turns`} in a shape a provider lane ` +
+                `rejects, so the request was repaired on its way out: ${[...new Set(fresh.map((r) => FORM_SENTENCE[r.form]))].join("; ")}. ` +
+                `The transcript is unchanged and every later request is repaired the same way; announced once per run.`,
+            detail: { repairs: fresh.map((r) => ({ form: r.form, toolCallIds: [...r.toolCallIds] })), sessionId: ids.sessionId, runId: ids.runId },
+        });
+    };
+}

package/dist/core/session-reconcile.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "../internal/harness-types.js";
+import type { ToolResultMessage } from "../internal/llm.js";
 import type { Session } from "./session.js";
 import type { ToolEffect } from "./types.js";
 /**
@@ -116,6 +117,40 @@ export declare const INTERRUPTED_BY_USER_FOR_TOOL_USE_MARKER = "[Request interru
 export declare function appendInterruptionMarker(session: Session, opts: {
     toolUseInFlight: boolean;
 }): Promise<string>;
+/** One synthetic interrupted result: what a call with no recorded result is closed with. */
+export interface InterruptedResult {
+    toolCallId: string;
+    toolName: string;
+    /** The model-facing text. */
+    text: string;
+    /** Which of the two honest states the call is closed in. */
+    errorKind: ReconciledErrorKind;
+}
+/**
+ * The ONE mint of interrupted-result content for a batch of calls that have no recorded result. Two readers: the
+ * persisted reconcile ({@link reconcileInterruptedSession}) and the request view's tool-turn law
+ * (`engine/llm/tool-turns.ts`, which closes a call on the wire only and never writes the transcript) — so a call
+ * closed either way reads the same to the model.
+ *
+ * `toolEffects` / `startedToolCallIds` as on {@link reconcileInterruptedSession}; absent ⇒ every call gets the
+ * conservative unknown-outcome wording. The first call of each class in the batch states it in full and the rest
+ * point back at it (scoped to this call, so a later batch always starts from the full wording again).
+ */
+export declare function interruptedResults(calls: readonly {
+    toolCallId: string;
+    toolName: string;
+}[], toolEffects?: Map<string, ToolEffect>, startedToolCallIds?: ReadonlySet<string>): InterruptedResult[];
+/** Is `message` an INTERRUPTED CLOSE — a result minted to stand in for one that was never recorded (this family's
+ *  two-valued `details.errorKind`, written by the reconcile here and by the loop's turn-scoped interrupt)? A close
+ *  says only "no result was recorded", so it is void beside a recorded result for the same call. Total: a tool's
+ *  `details` is the tool's value, so an unreadable one reads as "not a close" (one guarded read per member). */
+export declare function isInterruptedClose(message: {
+    details?: unknown;
+}): boolean;
+/** The `toolResult` message for one {@link InterruptedResult} — the persisted and the request-view closes are this one shape. */
+export declare function interruptedResultMessage(result: InterruptedResult, timestamp: number): ToolResultMessage<{
+    errorKind: ReconciledErrorKind;
+}>;
 /**
  * Reconcile a resumed session's active branch: close any orphan tool calls with a synthetic
  * interrupted `toolResult` (never re-running the tool). Returns what was recovered.

package/dist/core/session-reconcile.js

@@ -1,3 +1,4 @@
+import { readMember } from "./thrown-value.js";
 const INTERRUPTED_UNKNOWN = "[INTERRUPTED] The previous run ended before this tool call's result was recorded. Its outcome " +
     "is UNKNOWN — the action may have completed, partially completed, or never run. Do not assume " +
     "success or failure. Before relying on it: if it is safe to read, query the current state to " +
@@ -96,30 +97,40 @@ export async function appendInterruptionMarker(session, opts) {
         timestamp: Date.now(),
     });
 }
-export async function reconcileInterruptedSession(session, toolEffects, suspendedBatch, startedToolCallIds) {
-    const { messages } = await session.buildContext();
-    const orphans = findOrphanToolCalls(messages, suspendedBatch).filter((o) => o.kind !== "result");
-    const recovered = [];
+export function interruptedResults(calls, toolEffects, startedToolCallIds) {
     const statedInFull = new Set();
-    for (const orphan of orphans) {
-        const effect = toolEffects?.get(orphan.toolName) ?? "write";
+    return calls.map(({ toolCallId, toolName }) => {
+        const effect = toolEffects?.get(toolName) ?? "write";
         const effectText = effect === "read" ? INTERRUPTED_SAFE : effect === "idempotent" ? INTERRUPTED_IDEMPOTENT : INTERRUPTED_UNKNOWN;
-        const neverStarted = startedToolCallIds !== undefined && !startedToolCallIds.has(orphan.toolCallId);
-        const fullText = neverStarted ? INTERRUPTED_NEVER_STARTED : effectText;
+        const neverStarted = startedToolCallIds !== undefined && !startedToolCallIds.has(toolCallId);
         const cls = neverStarted ? "never_started" : effect === "read" ? "read" : effect === "idempotent" ? "idempotent" : "unknown";
-        const text = statedInFull.has(cls) ? REPEAT_TEXT[cls] : fullText;
+        const text = statedInFull.has(cls) ? REPEAT_TEXT[cls] : neverStarted ? INTERRUPTED_NEVER_STARTED : effectText;
         statedInFull.add(cls);
-        const errorKind = neverStarted ? "interrupted_never_started" : "interrupted_outcome_unknown";
-        const entryId = await session.appendMessage({
-            role: "toolResult",
-            toolCallId: orphan.toolCallId,
-            toolName: orphan.toolName,
-            content: [{ type: "text", text }],
-            details: { errorKind },
-            isError: true,
-            timestamp: Date.now(),
-        });
-        recovered.push({ ...orphan, entryId, text, errorKind });
+        return { toolCallId, toolName, text, errorKind: neverStarted ? "interrupted_never_started" : "interrupted_outcome_unknown" };
+    });
+}
+export function isInterruptedClose(message) {
+    const kind = readMember(readMember(message, "details"), "errorKind");
+    return kind === "interrupted_never_started" || kind === "interrupted_outcome_unknown";
+}
+export function interruptedResultMessage(result, timestamp) {
+    return {
+        role: "toolResult",
+        toolCallId: result.toolCallId,
+        toolName: result.toolName,
+        content: [{ type: "text", text: result.text }],
+        details: { errorKind: result.errorKind },
+        isError: true,
+        timestamp,
+    };
+}
+export async function reconcileInterruptedSession(session, toolEffects, suspendedBatch, startedToolCallIds) {
+    const { messages } = await session.buildContext();
+    const orphans = findOrphanToolCalls(messages, suspendedBatch).filter((o) => o.kind !== "result");
+    const recovered = [];
+    for (const result of interruptedResults(orphans, toolEffects, startedToolCallIds)) {
+        const entryId = await session.appendMessage(interruptedResultMessage(result, Date.now()));
+        recovered.push({ toolCallId: result.toolCallId, toolName: result.toolName, entryId, text: result.text, errorKind: result.errorKind });
     }
     return { recovered };
 }

package/dist/core/side-query.js

@@ -1,3 +1,4 @@
+import { ensureToolTurnInvariants } from "../internal/llm.js";
 import { resolveTaskModel } from "./roles.js";
 import { readDegradation } from "../brain/degrading.js";
 import { cacheFamilyOf, uncachedInputTokensOf } from "./runner/usage-accounting.js";
@@ -33,14 +34,15 @@ export async function runSideQuery(spec, deps) {
             };
         }
         if (m.role === "toolResult") {
-            return { role: "toolResult", toolCallId: m.toolCallId, toolName: m.toolName, content: m.content, isError: m.isError ?? false, timestamp };
+            const details = m.details;
+            return { role: "toolResult", toolCallId: m.toolCallId, toolName: m.toolName, content: m.content, isError: m.isError ?? false, timestamp, ...(details !== undefined ? { details } : {}) };
         }
         return { role: "user", content: m.content, timestamp };
     };
     const effectiveSystemPrompt = spec.systemPrompt ?? resolved.systemPrompt;
     const context = {
         ...(effectiveSystemPrompt !== undefined ? { systemPrompt: effectiveSystemPrompt } : {}),
-        messages: spec.messages.map(normalize),
+        messages: ensureToolTurnInvariants(spec.messages.map(normalize)).messages,
         ...(spec.tools !== undefined && spec.tools.length > 0
             ? { tools: spec.tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })) }
             : {}),

package/dist/engine/harness/agent-harness.d.ts

@@ -1,4 +1,5 @@
 import type { ActorAssertion, AssistantMessage, ImageContent, Model, UserMessage } from "../llm/index.js";
+import { type ToolTurnRepair } from "../llm/index.js";
 import type { HaltRemainingDirective } from "../loop/types.js";
 import type { AgentMessage, AgentTool, LoopMalformedToolUseRecovery, LoopThinkingOnlyRecovery, LoopTruncatedOutputRecovery, QueueMode, ThinkingLevel } from "../loop/types.js";
 import { type EngineSegment } from "../../core/untrusted-text.js";
@@ -189,6 +190,10 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     private thinkingLevel;
     /** RB-30 terminal fix — runner-set sink for engine-note payloads left undrained at agent_end. */
     onUndrainedEngineNotes?: (payloads: unknown[]) => void;
+    /** Runner-set sink for the provider boundary's tool-turn repairs ({@link ensureToolTurnInvariants}) — called
+     *  with every request view that needed one (the transcript is never rewritten, so a broken turn is repaired, and
+     *  reported, on each request; the sink owns its dedup). Advisory: a throwing sink never breaks the request. */
+    onToolTurnRepaired?: (repairs: readonly ToolTurnRepair[]) => void;
     /** backlog #259 — USER-authored queue remnants at agent_end: steers/follow-ups whose receipts said
      *  "queued" but that no turn will ever drain (the run ended first). The engine-note sweep above
      *  hands ENGINE payloads back for redelivery; user inputs have no redelivery semantics (a steer
@@ -226,6 +231,8 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
      *  gated: its splice opens a NEW run (idle-park redelivery), and a halt belongs to the run that
      *  minted it. */
     engineInjectionsHeld?: () => boolean;
+    /** The provider boundary's tool-turn law: the repaired view goes to the brain, the repairs to the runner's sink. */
+    private holdToolTurnLaw;
     /** RB-30 R2 belt-and-braces: runner-callable idempotent recovery for exit paths that reach
      *  neither agent_end nor abort() (a pre-prompt throw after prepare). Swept entries are removed,
      *  so a double call is a no-op. */

package/dist/engine/harness/agent-harness.js

@@ -1,4 +1,4 @@
-import { createAssistantMessageEventStream, snapshotActorAssertion, stripEngineMetadata } from "../llm/index.js";
+import { createAssistantMessageEventStream, ensureToolTurnInvariants, snapshotActorAssertion, stripEngineMetadata } from "../llm/index.js";
 import { runAgentLoop } from "../loop/agent-loop.js";
 import { resolveAgentCoreStreamFn } from "../loop/runtime-deps.js";
 import { normalizeEngineSegments } from "../../core/untrusted-text.js";
@@ -211,10 +211,22 @@ export class AgentHarness {
     modelRef;
     thinkingLevel;
     onUndrainedEngineNotes;
+    onToolTurnRepaired;
     onUndrainedUserInputs;
     onEngineNoteConsumed;
     onFrameCommitted;
     engineInjectionsHeld;
+    holdToolTurnLaw(messages) {
+        const view = ensureToolTurnInvariants(messages);
+        if (view.repairs.length > 0) {
+            try {
+                this.onToolTurnRepaired?.(view.repairs);
+            }
+            catch {
+            }
+        }
+        return view.messages;
+    }
     recoverUndrainedEngineNotes() {
         this.sweepUndrainedEngineNotes([this.drainedPendingInjection, this.nextTurnQueue, this.steerQueue, this.followUpQueue]);
     }
@@ -620,7 +632,7 @@ export class AgentHarness {
             ...(this.streamingToolExecution === true && (this.getHandlers("tool_call")?.size ?? 0) === 0
                 ? { streamingToolExecution: true }
                 : {}),
-            convertToLlm: (messages) => stripEngineMetadata(convertToLlm(messages)),
+            convertToLlm: (messages) => this.holdToolTurnLaw(stripEngineMetadata(convertToLlm(messages))),
             shouldStopAfterTurn: () => this.consultStopLatch("post_turn"),
             shouldHaltBeforeTurn: () => this.consultStopLatch("pre_turn"),
             transformContext: async (messages, signal) => {

package/dist/engine/llm/index.d.ts

@@ -9,3 +9,4 @@ export * from "./types.js";
 export * from "./diagnostics.js";
 export * from "./event-stream.js";
 export * from "./validation.js";
+export * from "./tool-turns.js";

package/dist/engine/llm/index.js

@@ -2,3 +2,4 @@ export * from "./types.js";
 export * from "./diagnostics.js";
 export * from "./event-stream.js";
 export * from "./validation.js";
+export * from "./tool-turns.js";

package/dist/engine/llm/tool-turns.d.ts

@@ -0,0 +1,20 @@
+import type { Message } from "./types.js";
+/** What the law restored — the `forms` of a `context.tool_turn_repaired` notice. */
+export declare const TOOL_TURN_REPAIR_FORMS: readonly ["trailing_text", "late_result", "missing_result", "duplicate_result"];
+export type ToolTurnRepairForm = (typeof TOOL_TURN_REPAIR_FORMS)[number];
+/** One restoration on one assistant message. */
+export interface ToolTurnRepair {
+    readonly form: ToolTurnRepairForm;
+    /** The calls concerned, in call order — for `trailing_text` every call of the message; otherwise the calls whose
+     *  result was moved up, synthesized, or folded with a second one. */
+    readonly toolCallIds: readonly string[];
+}
+export interface ToolTurnView {
+    /** The request view — the input array itself when {@link repairs} is empty. */
+    readonly messages: Message[];
+    readonly repairs: readonly ToolTurnRepair[];
+}
+/** The text standing between two results recorded for one call when the view folds them into one. */
+export declare const SECOND_RESULT_SEPARATOR = "[another result was recorded for this same call:]";
+/** Restore the tool-turn law on a provider-bound message list (see the module header). */
+export declare function ensureToolTurnInvariants(messages: Message[]): ToolTurnView;

package/dist/engine/llm/tool-turns.js

@@ -0,0 +1,91 @@
+import { interruptedResultMessage, interruptedResults, isInterruptedClose } from "../../core/session-reconcile.js";
+export const TOOL_TURN_REPAIR_FORMS = ["trailing_text", "late_result", "missing_result", "duplicate_result"];
+function callsOf(m) {
+    return m.role === "assistant" && Array.isArray(m.content) ? m.content.filter((c) => c?.type === "toolCall") : [];
+}
+export const SECOND_RESULT_SEPARATOR = "[another result was recorded for this same call:]";
+export function ensureToolTurnInvariants(messages) {
+    const anchor = [];
+    messages.forEach((m, i) => anchor.push(m.role === "toolResult" && i > 0 ? anchor[i - 1] : i));
+    const sites = new Map();
+    const ownerOf = new Map();
+    const resultsOf = new Map();
+    messages.forEach((m, i) => {
+        if (m.role === "assistant") {
+            for (const call of callsOf(m)) {
+                const list = sites.get(call.id) ?? [];
+                if (list.at(-1) !== i)
+                    list.push(i);
+                sites.set(call.id, list);
+            }
+            return;
+        }
+        if (m.role !== "toolResult")
+            return;
+        const all = sites.get(m.toolCallId) ?? [];
+        if (all.length === 0)
+            return;
+        const owner = all.at(-1);
+        ownerOf.set(i, owner);
+        const batch = resultsOf.get(owner);
+        if (batch === undefined)
+            resultsOf.set(owner, [i]);
+        else
+            batch.push(i);
+    });
+    const repairs = [];
+    const out = [];
+    messages.forEach((m, i) => {
+        if (ownerOf.has(i))
+            return;
+        const calls = callsOf(m);
+        if (calls.length === 0) {
+            out.push(m);
+            return;
+        }
+        const assistant = m;
+        const firstCall = assistant.content.findIndex((c) => c?.type === "toolCall");
+        const trails = assistant.content.slice(firstCall).some((c) => c?.type !== "toolCall");
+        out.push(trails ? { ...assistant, content: [...assistant.content.filter((c) => c?.type !== "toolCall"), ...calls] } : assistant);
+        if (trails)
+            repairs.push({ form: "trailing_text", toolCallIds: calls.map((c) => c.id) });
+        const byId = new Map();
+        for (const call of calls)
+            if (!byId.has(call.id))
+                byId.set(call.id, call);
+        const ids = [...byId.keys()];
+        const recorded = new Map();
+        for (const r of resultsOf.get(i) ?? []) {
+            const id = messages[r].toolCallId;
+            recorded.set(id, [...(recorded.get(id) ?? []), r]);
+        }
+        const sent = new Map();
+        const late = [];
+        const duplicate = [];
+        for (const [id, at] of recorded) {
+            const real = at.filter((r) => !isInterruptedClose(messages[r]));
+            const chosen = real.length > 0 ? real : at.slice(0, 1);
+            sent.set(id, chosen.map((r) => messages[r]).reduce(foldResults));
+            if (anchor[chosen[0]] !== i)
+                late.push(id);
+            if (at.length > 1)
+                duplicate.push(id);
+        }
+        out.push(...sent.values());
+        const missing = [...byId.values()].filter((c) => !sent.has(c.id));
+        for (const result of interruptedResults(missing.map((c) => ({ toolCallId: c.id, toolName: c.name })))) {
+            out.push(interruptedResultMessage(result, assistant.timestamp));
+        }
+        const inCallOrder = (set) => ids.filter((id) => set.includes(id));
+        if (late.length > 0)
+            repairs.push({ form: "late_result", toolCallIds: inCallOrder(late) });
+        if (missing.length > 0)
+            repairs.push({ form: "missing_result", toolCallIds: missing.map((c) => c.id) });
+        if (duplicate.length > 0)
+            repairs.push({ form: "duplicate_result", toolCallIds: inCallOrder(duplicate) });
+    });
+    return repairs.length === 0 ? { messages, repairs } : { messages: out, repairs };
+}
+function foldResults(first, second) {
+    return { ...first, content: [...first.content, { type: "text", text: SECOND_RESULT_SEPARATOR }, ...second.content], isError: first.isError && second.isError };
+}

package/dist/internal/llm.d.ts

@@ -4,5 +4,5 @@
  * design/118 ①②: the layer is now first-party (`src/engine/llm/`, naturalized out of the vendored
  * llm-core); the facade stays so consumers never notice which side a symbol lives on.
  */
-export { createAssistantMessageEventStream, snapshotActorAssertion, stripEngineMetadata } from "../engine/llm/index.js";
-export type { ActorAssertion, AnthropicMessagesCompat, OpenAICompletionsCompat, OpenAIResponsesCompat, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, Model, ResilienceOptions, RouteAdjudication, RouteCredential, RouteCredentialSource, RoutePairingConfig, RoutePairingPosture, RouteRefusalCode, RouteRefusalDetail, SimpleStreamOptions, StallTimeouts, StopReason, StreamFn, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, Usage, UserMessage, } from "../engine/llm/index.js";
+export { createAssistantMessageEventStream, ensureToolTurnInvariants, snapshotActorAssertion, stripEngineMetadata } from "../engine/llm/index.js";
+export type { ActorAssertion, AnthropicMessagesCompat, OpenAICompletionsCompat, OpenAIResponsesCompat, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, Model, ResilienceOptions, RouteAdjudication, RouteCredential, RouteCredentialSource, RoutePairingConfig, RoutePairingPosture, RouteRefusalCode, RouteRefusalDetail, SimpleStreamOptions, StallTimeouts, StopReason, StreamFn, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, ToolTurnRepair, Usage, UserMessage, } from "../engine/llm/index.js";

package/dist/internal/llm.js

@@ -1 +1 @@
-export { createAssistantMessageEventStream, snapshotActorAssertion, stripEngineMetadata } from "../engine/llm/index.js";
+export { createAssistantMessageEventStream, ensureToolTurnInvariants, snapshotActorAssertion, stripEngineMetadata } from "../engine/llm/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.37.0",
+  "version": "7.37.1",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",

package/wire-changes/core@7.37.1.json

@@ -0,0 +1,122 @@
+{
+  "repo": "core",
+  "version": "7.37.1",
+  "from": "979f761e382593d192c6c5b3170cb82cc676677c",
+  "to": "072c5d4502bddacb7b28e2e3f47653ad28c008a5",
+  "added": [],
+  "removed": [],
+  "changed": [],
+  "narrowed": [],
+  "closedSetMembers": [
+    {
+      "set": "ENGINE_NOTICE_CODES",
+      "at": [
+        "src/core/governance-codes.ts:344"
+      ],
+      "newSet": false,
+      "added": [
+        "context.tool_turn_repaired"
+      ],
+      "removed": [],
+      "breaking": false,
+      "criteriaCovered": true
+    },
+    {
+      "set": "TOOL_TURN_REPAIR_FORMS",
+      "at": [
+        "src/engine/llm/tool-turns.ts:43"
+      ],
+      "newSet": true,
+      "added": [
+        "duplicate_result",
+        "late_result",
+        "missing_result",
+        "trailing_text"
+      ],
+      "removed": [],
+      "breaking": false,
+      "criteriaCovered": false
+    },
+    {
+      "set": "ToolTurnRepairForm",
+      "at": [
+        "src/engine/llm/tool-turns.ts:44"
+      ],
+      "newSet": true,
+      "added": [
+        "duplicate_result",
+        "late_result",
+        "missing_result",
+        "trailing_text"
+      ],
+      "removed": [],
+      "breaking": false,
+      "criteriaCovered": false
+    }
+  ],
+  "closedSetsUnreadable": [],
+  "typeKeys": [],
+  "typeKeysUnreadableArms": [],
+  "typeKeysFlattenedCount": 219,
+  "declarationMoves": [],
+  "mintMoves": [],
+  "criteriaObserves": [
+    {
+      "kind": "engineNoticeCode",
+      "name": "context.tool_turn_repaired",
+      "assertions": [
+        "G1.b",
+        "G3.a",
+        "G3.b",
+        "G3.c"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "AssistantMessage.content",
+      "assertions": [
+        "G1.a",
+        "G1.c",
+        "G2.a",
+        "G2.b"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "AssistantMessage.errorMessage",
+      "assertions": [
+        "G2.c",
+        "G4.a",
+        "G4.b"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "AssistantMessage.stopReason",
+      "assertions": [
+        "G2.c"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "EngineNotice.detail",
+      "assertions": [
+        "G1.b"
+      ]
+    }
+  ],
+  "consumersHint": {
+    "cli": [
+      "ENGINE_NOTICE_CODES"
+    ],
+    "server": [
+      "ENGINE_NOTICE_CODES"
+    ],
+    "sdk": [
+      "ENGINE_NOTICE_CODES"
+    ],
+    "note": "scanned cli@6b6025f7 server@65b2df99 sdk@a90a03a — a name listed is MENTIONED there today, which is evidence of consumption, not proof of it"
+  },
+  "breakingCount": 0,
+  "breakingItems": []
+}