@sema-agent/core 7.37.1 → 7.38.1

package/dist/brain/open-responses.js

@@ -2,7 +2,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, placeTurnNotes } from "./stream-shared.js";
-import { admitToolCallId, providerResultIds, providerToolCallId } from "./tool-call-id.js";
+import { admitToolCallId, providerResultIds, providerToolCallId, responseToolCallIds } from "./tool-call-id.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
 import { OUTPUT_CAP_KEYS, RESPONSES_RESERVED, applyExtraBody, effectiveOutputCap, lockHeader, mergeHeaders } from "./request-params.js";
@@ -199,7 +199,7 @@ function responsesErrorCode(code) {
 const INCOMPLETE_MAX_OUTPUT_TOKENS = "max_output_tokens";
 const INCOMPLETE_CONTENT_FILTER = "content_filter";
 const RESPONSE_INCOMPLETE_WARNING = 'The response above may be incomplete: the endpoint reported status "incomplete" with no reason this client recognises.';
-function closeFunctionCall(acc) {
+function closeFunctionCall(acc, responseIds) {
     if (acc.closedTc)
         return acc.closedTc;
     if (!acc.name)
@@ -207,7 +207,7 @@ function closeFunctionCall(acc) {
     const args = parseStreamedToolArgs(acc.args);
     if (args === undefined)
         return undefined;
-    const { engineId, wireId } = admitToolCallId(acc.callId, "call_");
+    const { engineId, wireId } = admitToolCallId(acc.callId, "call_", responseIds);
     acc.closedTc = { type: "toolCall", id: engineId, ...(wireId !== engineId ? { wireId } : {}), name: acc.name, arguments: args };
     return acc.closedTc;
 }
@@ -305,6 +305,7 @@ export function createOpenResponsesBrain(config = {}) {
             makeParser: (ctrl) => {
                 const { out, partial } = ctrl;
                 const items = new Map();
+                const responseIds = responseToolCallIds();
                 let usageRaw;
                 let responseId;
                 let terminalStatus;
@@ -412,7 +413,7 @@ export function createOpenResponsesBrain(config = {}) {
                             out.push({ type: "text_end", contentIndex: index, content: messageFace(acc), partial: { ...partial } });
                     }
                     else {
-                        const tc = closeFunctionCall(acc);
+                        const tc = closeFunctionCall(acc, responseIds);
                         if (tc)
                             out.push({ type: "toolcall_end", contentIndex: index, toolCall: tc, partial: { ...partial } });
                     }
@@ -650,7 +651,7 @@ export function createOpenResponsesBrain(config = {}) {
                                 }
                             }
                             else {
-                                const tc = closeFunctionCall(acc);
+                                const tc = closeFunctionCall(acc, responseIds);
                                 if (tc) {
                                     toolCalls.push(tc);
                                     finalContent.push(tc);
@@ -675,15 +676,15 @@ export function createOpenResponsesBrain(config = {}) {
                         const toolError = toolErrorParts.length > 0 ? toolErrorParts.join(" | ") : undefined;
                         const notes = [];
                         if (malformed.length > 0) {
-                            notes.push(`\n[note: ${malformed.length} tool call(s) were truncated (status="${terminalLabel}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`);
+                            notes.push({ cause: "truncated", count: malformed.length, text: `\n[note: ${malformed.length} tool call(s) were truncated (status="${terminalLabel}") and dropped — re-issue them next turn: ${malformed.join("; ")}]` });
                         }
                         if (unnamed.length > 0) {
-                            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("; ")}]`);
+                            notes.push({ cause: "unnamed", count: unnamed.length, 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("; ")}]` });
                         }
                         if (malformedFrames > 0) {
-                            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)})]`);
+                            notes.push({ cause: "bad_frame", count: malformedFrames, 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)})]` });
                         }
-                        placeTurnNotes(finalContent, notes);
+                        placeTurnNotes(partial, 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

@@ -2,7 +2,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, placeTurnNotes, truncationCauseClause } from "./stream-shared.js";
-import { admitToolCallId, providerResultIds, providerToolCallId } from "./tool-call-id.js";
+import { admitToolCallId, providerResultIds, providerToolCallId, responseToolCallIds } from "./tool-call-id.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
 import { OPENAI_RESERVED, OUTPUT_CAP_KEYS, applyExtraBody, effectiveOutputCap, lockHeader, mergeHeaders } from "./request-params.js";
@@ -12,7 +12,7 @@ import { declaredOffSpelling, mintEffortWireValue, reasoningRequestCarried } fro
 import { runStreamingBrain } from "./stream-engine.js";
 import { refuseRetiredTimeoutKnobs } from "./timeout.js";
 import { resolveFetch } from "./transport.js";
-function closeToolCallAccum(acc) {
+function closeToolCallAccum(acc, responseIds) {
     if (acc.closedTc)
         return acc.closedTc;
     if (!acc.name)
@@ -20,7 +20,7 @@ function closeToolCallAccum(acc) {
     const args = parseStreamedToolArgs(acc.args);
     if (args === undefined)
         return undefined;
-    const { engineId, wireId } = admitToolCallId(acc.id, "call_");
+    const { engineId, wireId } = admitToolCallId(acc.id, "call_", responseIds);
     acc.closedTc = { type: "toolCall", id: engineId, ...(wireId !== engineId ? { wireId } : {}), name: acc.name, arguments: args };
     return acc.closedTc;
 }
@@ -377,6 +377,7 @@ export function createOpenAIBrain(config = {}) {
                 let thinkingClosed = false;
                 let textIndex = 0;
                 const toolAccum = new Map();
+                const responseIds = responseToolCallIds();
                 let finishReason = null;
                 const terminalFrameSeen = () => finishReason != null;
                 let usageRaw;
@@ -495,7 +496,7 @@ export function createOpenAIBrain(config = {}) {
                                             continue;
                                         if (prevAcc.args === "")
                                             continue;
-                                        const closed = closeToolCallAccum(prevAcc);
+                                        const closed = closeToolCallAccum(prevAcc, responseIds);
                                         if (closed) {
                                             out.push({ type: "toolcall_end", contentIndex: prevIdx, toolCall: closed, partial: { ...partial } });
                                         }
@@ -536,7 +537,7 @@ export function createOpenAIBrain(config = {}) {
                                 unnamed.push(`id="${acc.id || "?"}"(${acc.args.slice(0, 200)})`);
                                 continue;
                             }
-                            const tc = closeToolCallAccum(acc);
+                            const tc = closeToolCallAccum(acc, responseIds);
                             if (tc) {
                                 toolCalls.push(tc);
                                 finalContent.push(tc);
@@ -579,15 +580,15 @@ export function createOpenAIBrain(config = {}) {
                         const noUsableContent = toolCalls.length === 0 && !accumText.trim();
                         const notes = [];
                         if (malformed.length > 0) {
-                            notes.push(`\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`);
+                            notes.push({ cause: "truncated", count: malformed.length, text: `\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) {
-                            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("; ")}]`);
+                            notes.push({ cause: "unnamed", count: unnamed.length, 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("; ")}]` });
                         }
                         if (malformedFrames > 0) {
-                            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)})]`);
+                            notes.push({ cause: "bad_frame", count: malformedFrames, 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)})]` });
                         }
-                        placeTurnNotes(finalContent, notes);
+                        placeTurnNotes(partial, finalContent, notes);
                         const truncatedEmpty = finishReason === "length" && noUsableContent && !toolError;
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const safetyCut = finishReason === "content_filter";

package/dist/brain/status-sink.d.ts

@@ -71,7 +71,7 @@ export type BrainTelemetry = {
  *  and the field is absent. One event per provider response per field. */
  | {
     kind: "echo_dropped";
-    field: "requestId" | "responseModel";
+    field: "requestId" | "responseModel" | "apiErrorCode";
 };
 /** Run `fn` with a per-task brain-telemetry sink in scope (Runner-side; compose with runWithStatusSink). */
 export declare function runWithBrainTelemetry<T>(emit: (t: BrainTelemetry) => void, fn: () => Promise<T>): Promise<T>;

package/dist/brain/stream-engine.js

@@ -1,7 +1,7 @@
 import { createAssistantMessageEventStream, } from "../internal/llm.js";
 import { STREAM_TORN_WARNING } from "./stream-shared.js";
 import { FLOOR_OUTPUT_TOKENS, parseContextOverflow, planOutputCapAdjustment } from "./context-overflow.js";
-import { abortLikeName, BrainError, brainErrorCodeOf, classifyConnectFailure, classifyFetchThrow, classifyHttp, describeNetworkError, namesTheFailure, readProviderRequestId } from "./errors.js";
+import { abortLikeName, BrainError, brainErrorCodeOf, classifyConnectFailure, classifyFetchThrow, classifyHttp, describeNetworkError, isProviderEchoShape, namesTheFailure, readProviderErrorCode, readProviderRequestId, refusedTheRequest } from "./errors.js";
 import { stripUrlCredentials } from "./route-adjudicator.js";
 import { classifyInputTooLong } from "./input-too-long.js";
 import { FAST_MAX_BACKOFF_MS, providerWaitHint, retryBackoffMs } from "./retry.js";
@@ -304,6 +304,9 @@ export function runStreamingBrain(args) {
                     errorMsg.apiErrorStatus = statusNum;
                 if (requestIdSeen !== undefined)
                     errorMsg.requestId = requestIdSeen;
+                const providerCode = readMember(err, "providerCode");
+                if (refusedTheRequest(statusNum) && typeof providerCode === "string" && isProviderEchoShape(providerCode))
+                    errorMsg.apiErrorCode = providerCode;
             }
         }
         errorMsg.usageMissing = true;
@@ -582,7 +585,12 @@ export function runStreamingBrain(args) {
                     const detail = overflowBody ?? (r ? (await readErrorBody(r, signal)).text : "");
                     const status = r?.status ?? 0;
                     const itl = classifyInputTooLong(status, detail);
-                    throw new BrainError(classifyHttp(status), `${httpLabel} HTTP ${status || "ERR"}: ${detail.slice(0, 500)}${overflowDeclineNote}`, status, { apiError: true, ...(itl === "yes" ? { inputTooLong: true } : itl === "no" ? { inputTooLongRuledOut: true } : {}) });
+                    const providerCode = refusedTheRequest(status) ? readProviderErrorCode(detail) : undefined;
+                    throw new BrainError(classifyHttp(status), `${httpLabel} HTTP ${status || "ERR"}: ${detail.slice(0, 500)}${overflowDeclineNote}`, status, {
+                        apiError: true,
+                        ...(itl === "yes" ? { inputTooLong: true } : itl === "no" ? { inputTooLongRuledOut: true } : {}),
+                        ...(providerCode !== undefined ? { providerCode } : {}),
+                    });
                 }
                 finally {
                     cc.abort();

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

@@ -1,5 +1,5 @@
 import { type RepetitionEvent } from "./repetition.js";
-import type { AssistantMessage } from "../internal/llm.js";
+import { type AssistantMessage, type StreamDropCause } 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
@@ -29,14 +29,22 @@ import type { AssistantMessage } from "../internal/llm.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;
+/** One drop note of a turn: what was dropped, how many, and the sentence the model reads. */
+export interface TurnNote {
+    readonly cause: StreamDropCause;
+    readonly count: number;
+    readonly text: string;
+}
 /**
  * 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.
+ * rejects a `tool_use` followed by anything but another `tool_use`. The same notes are stamped on the turn's message as
+ * its stream drops (`stampStreamDrops`), the run's source for the person's line (`task.tool_turn_incomplete`): the
+ * model's sentence and the person's line come from one list. One rule for the three lanes.
  */
-export declare function placeTurnNotes(content: AssistantMessage["content"], notes: readonly string[]): void;
+export declare function placeTurnNotes(message: Pick<AssistantMessage, "diagnostics">, content: AssistantMessage["content"], notes: readonly TurnNote[]): 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

package/dist/brain/stream-shared.js

@@ -1,6 +1,7 @@
 import { isProviderEchoShape, providerEchoReading } from "./errors.js";
 import { inspectDegenerate } from "./repetition.js";
 import { emitBrainTelemetry } from "./status-sink.js";
+import { stampStreamDrops } from "../internal/llm.js";
 export const STREAM_TORN_WARNING = "Connection closed mid-response. The response above may be incomplete.";
 export function parseStreamedToolArgs(json) {
     if (!json)
@@ -16,11 +17,12 @@ export function parseStreamedToolArgs(json) {
         return undefined;
     return parsed;
 }
-export function placeTurnNotes(content, notes) {
+export function placeTurnNotes(message, 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 })));
+    content.splice(at === -1 ? content.length : at, 0, ...notes.map(({ text }) => ({ type: "text", text })));
+    stampStreamDrops(message, notes);
 }
 export function truncationCauseClause(facts) {
     const { capStop, outputTokens, capTokens, terminalFrameSeen } = facts;

package/dist/brain/tool-call-id.d.ts

@@ -12,14 +12,35 @@ export interface AdmittedToolCallId {
     readonly engineId: string;
     readonly wireId: string;
 }
-/** Why a raw id is folded: `"charset"` — it holds a character outside the admitted alphabet (a control byte, a space,
- *  a non-ASCII unit, or the fold separator); `"length"` — every character is admitted and it is longer than 128. */
-export type ToolCallIdFoldReason = "charset" | "length";
-/** The fold reading of a non-empty raw id: `undefined` ⇒ admitted verbatim; otherwise why it is folded. */
-export declare function toolCallIdFoldReason(raw: string): ToolCallIdFoldReason | undefined;
-/** Admit a provider-minted tool-call id (see the module header for the three arms). Pure: announcing a fold is the
- *  run's job, read off `ToolCall.wireId`. */
-export declare function admitToolCallId(raw: unknown, prefix: string): AdmittedToolCallId;
+/** Why a call's id was folded: `"charset"` — the raw holds a character outside the admitted alphabet (a control byte,
+ *  a space, a non-ASCII unit, or the fold separator); `"length"` — every character is admitted and it is longer than
+ *  128; `"duplicate"` — an earlier call in the same response carried the same raw id, so this one was renamed. */
+export declare const TOOL_CALL_ID_FOLD_REASONS: readonly ["charset", "length", "duplicate"];
+export type ToolCallIdFoldReason = (typeof TOOL_CALL_ID_FOLD_REASONS)[number];
+/** The fold reading of one non-empty raw id on its own: `undefined` ⇒ admitted verbatim; otherwise why its shape is
+ *  folded (`"duplicate"` is a reading of the response, never of one id). */
+export declare function toolCallIdFoldReason(raw: string): Exclude<ToolCallIdFoldReason, "duplicate"> | undefined;
+/** Why a call carries two ids, read off the call itself (a built-in brain's call and a host brain's alike):
+ *  `undefined` ⇒ one id, or an in-shape pair the admission did not mint (a host brain's own spelling); a provider id
+ *  outside the admitted shape ⇒ its shape reason; an in-shape provider id beside an engine id of the rename arm's
+ *  form ⇒ `"duplicate"`. */
+export declare function toolCallFoldReason(call: {
+    readonly id: string;
+    readonly wireId?: unknown;
+}): ToolCallIdFoldReason | undefined;
+/** What ONE provider response has admitted so far — the state the rename arm reads: every provider id handed out
+ *  (`handedOut`) and how many calls each raw id arrived on (`arrivals`). A brain holds one per response attempt
+ *  ({@link responseToolCallIds}; a retried response starts a new one). */
+export interface ResponseToolCallIds {
+    readonly handedOut: Set<string>;
+    readonly arrivals: Map<string, number>;
+}
+/** A fresh {@link ResponseToolCallIds} for one response attempt. */
+export declare function responseToolCallIds(): ResponseToolCallIds;
+/** Admit a provider-minted tool-call id (see the module header for the four arms). `response` = the response's
+ *  {@link ResponseToolCallIds}; absent ⇒ the single-call reading (no rename). Pure apart from recording the call in
+ *  `response`: announcing a fold is the run's job, read off the call ({@link toolCallFoldReason}). */
+export declare function admitToolCallId(raw: unknown, prefix: string, response?: ResponseToolCallIds): AdmittedToolCallId;
 /** The id a provider is handed for this call: its `wireId` when it carries one (a non-empty string), else its `id`. */
 export declare function providerToolCallId(call: {
     readonly id: string;

package/dist/brain/tool-call-id.js

@@ -6,25 +6,55 @@ const FOLD_DIGEST_HEX = 32;
 export function mintFallbackToolCallId(prefix) {
     return `${prefix}${Math.random().toString(36).slice(2)}`;
 }
+export const TOOL_CALL_ID_FOLD_REASONS = Object.freeze(["charset", "length", "duplicate"]);
 export function toolCallIdFoldReason(raw) {
     const separated = raw.includes(TOOL_CALL_ID_FOLD_SEPARATOR);
     if (!separated && isProviderEchoShape(raw))
         return undefined;
     return !separated && fitsProviderEchoCharset(raw) ? "length" : "charset";
 }
-export function admitToolCallId(raw, prefix) {
+export function toolCallFoldReason(call) {
+    const wireId = providerToolCallId(call);
+    if (wireId === call.id)
+        return undefined;
+    return toolCallIdFoldReason(wireId) ?? (RENAMED_ENGINE_ID.test(call.id) ? "duplicate" : undefined);
+}
+const RENAMED_ENGINE_ID = new RegExp(`^[\\x21-\\x7D]{1,${FOLD_BASE_CHARS}}${TOOL_CALL_ID_FOLD_SEPARATOR}[1-9][0-9]*${TOOL_CALL_ID_FOLD_SEPARATOR}[0-9a-f]{${FOLD_DIGEST_HEX}}$`);
+export function responseToolCallIds() {
+    return { handedOut: new Set(), arrivals: new Map() };
+}
+export function admitToolCallId(raw, prefix, response) {
     if (typeof raw !== "string" || raw === "") {
-        const id = mintFallbackToolCallId(prefix);
+        let id = mintFallbackToolCallId(prefix);
+        while (response?.handedOut.has(id) === true)
+            id = mintFallbackToolCallId(prefix);
+        response?.handedOut.add(id);
         return { engineId: id, wireId: id };
     }
-    return { engineId: engineIdOf(raw), wireId: raw };
+    if (response === undefined)
+        return { engineId: engineIdOf(raw), wireId: raw };
+    const arrival = (response.arrivals.get(raw) ?? 0) + 1;
+    response.arrivals.set(raw, arrival);
+    if (!response.handedOut.has(raw)) {
+        response.handedOut.add(raw);
+        return { engineId: engineIdOf(raw), wireId: raw };
+    }
+    let wireId = `${prefix}${digestOf(`${arrival}\u0000${raw}`)}`;
+    for (let attempt = 1; response.handedOut.has(wireId); attempt++)
+        wireId = `${prefix}${digestOf(`${arrival}\u0000${raw}\u0000${attempt}`)}`;
+    response.handedOut.add(wireId);
+    return { engineId: `${foldBase(raw)}${TOOL_CALL_ID_FOLD_SEPARATOR}${arrival}${TOOL_CALL_ID_FOLD_SEPARATOR}${digestOf(wireId)}`, wireId };
 }
 function engineIdOf(raw) {
     if (toolCallIdFoldReason(raw) === undefined)
         return raw;
-    const base = raw.slice(0, FOLD_BASE_CHARS).replace(/[^\x21-\x7D]/g, "-");
-    const digest = createHash("sha256").update(Buffer.from(raw, "utf16le")).digest("hex").slice(0, FOLD_DIGEST_HEX);
-    return `${base}${TOOL_CALL_ID_FOLD_SEPARATOR}${digest}`;
+    return `${foldBase(raw)}${TOOL_CALL_ID_FOLD_SEPARATOR}${digestOf(raw)}`;
+}
+function foldBase(raw) {
+    return raw.slice(0, FOLD_BASE_CHARS).replace(/[^\x21-\x7D]/g, "-");
+}
+function digestOf(value) {
+    return createHash("sha256").update(Buffer.from(value, "utf16le")).digest("hex").slice(0, FOLD_DIGEST_HEX);
 }
 export function providerToolCallId(call) {
     return typeof call.wireId === "string" && call.wireId !== "" ? call.wireId : call.id;

package/dist/brain/tool-call-repair.js

@@ -42,7 +42,7 @@ function extractCall(obj, toolNames, framed) {
     }
     return {
         type: "toolCall",
-        id: mintFallbackToolCallId(`repair_${name}_`),
+        id: mintFallbackToolCallId("repair_"),
         name,
         arguments: args,
     };

package/dist/core/a2a-task-state.js

@@ -1,4 +1,4 @@
-export const A2A_TASK_STATES = [
+export const A2A_TASK_STATES = Object.freeze([
     "submitted",
     "working",
     "input-required",
@@ -8,7 +8,7 @@ export const A2A_TASK_STATES = [
     "rejected",
     "auth-required",
     "unknown",
-];
+]);
 const CANCELLING_STOP_SOURCES = new Set(["user", "parent"]);
 export function toA2ATaskState(record) {
     switch (record.status) {

package/dist/core/artifact-host.js

@@ -1,14 +1,14 @@
 import { isAbsoluteForFamily, pathFamilyOf } from "../tools/fs/safety.js";
 import { thrownText } from "./thrown-value.js";
-export const ARTIFACT_ACTIONS = ["publish", "list", "read", "list_files", "read_file"];
-export const ARTIFACT_PLANES = ["hosted", "local-stub"];
-export const ARTIFACT_COMMIT_CERTAINTIES = ["throw_means_uncommitted", "uncertain"];
+export const ARTIFACT_ACTIONS = Object.freeze(["publish", "list", "read", "list_files", "read_file"]);
+export const ARTIFACT_PLANES = Object.freeze(["hosted", "local-stub"]);
+export const ARTIFACT_COMMIT_CERTAINTIES = Object.freeze(["throw_means_uncommitted", "uncertain"]);
 export const ARTIFACT_COMMIT_THROW_OUTCOME = {
     throw_means_uncommitted: "not_executed",
     uncertain: "unknown",
 };
-export const ARTIFACT_PUBLISH_CONTEXTS = ["pr_review", "workshop", "whiteboard", "prototype", "plain"];
-export const ARTIFACT_LIST_SCOPES = ["mine", "shared", "all"];
+export const ARTIFACT_PUBLISH_CONTEXTS = Object.freeze(["pr_review", "workshop", "whiteboard", "prototype", "plain"]);
+export const ARTIFACT_LIST_SCOPES = Object.freeze(["mine", "shared", "all"]);
 export const ARTIFACT_PLANE_CONTENT_ORIGIN = {
     hosted: "external",
     "local-stub": "local",
@@ -27,7 +27,7 @@ export const ARTIFACT_ACTION_CONCURRENCY_SAFE = {
     list_files: true,
     read_file: true,
 };
-export const ARTIFACT_HOST_FAILURE_CODES = ["conflict", "url_foreign", "forbidden", "payload_too_large", "not_found", "force_refused", "refused"];
+export const ARTIFACT_HOST_FAILURE_CODES = Object.freeze(["conflict", "url_foreign", "forbidden", "payload_too_large", "not_found", "force_refused", "refused"]);
 export const ARTIFACT_FAILURE_RESULT_CODE = {
     conflict: "artifact.publish_conflict",
     url_foreign: "artifact.url_foreign",

package/dist/core/ask-origin.js

@@ -1,4 +1,4 @@
-export const ASK_ORIGINS = ["content_question", "ancestor_marked", "org_unavailable", "org_rule", "rule_store_unavailable", "hook", "ask_rule", "denial_limit_fallback", "shell_gate_tighten", "safety_tighten", "policy"];
+export const ASK_ORIGINS = Object.freeze(["content_question", "ancestor_marked", "org_unavailable", "org_rule", "rule_store_unavailable", "hook", "ask_rule", "denial_limit_fallback", "shell_gate_tighten", "safety_tighten", "policy"]);
 const ASK_ORIGIN_SET = new Set(ASK_ORIGINS);
 export function isAskOrigin(v) {
     return ASK_ORIGIN_SET.has(v);
@@ -103,7 +103,7 @@ export const ORIGIN_IMPLIES_REAL_APPROVAL = {
     safety_tighten: false,
     policy: false,
 };
-export const PERSISTED_RULE_MANDATES = ["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "write_protection_unresolved"];
+export const PERSISTED_RULE_MANDATES = Object.freeze(["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "write_protection_unresolved"]);
 const PERSISTED_RULE_MANDATE_SET = new Set(PERSISTED_RULE_MANDATES);
 export function isPersistedRuleMandate(v) {
     return PERSISTED_RULE_MANDATE_SET.has(v);
@@ -149,7 +149,7 @@ export function safetyAxisOf(marks) {
     const shell = raised && marks.shellGated === true;
     return egress || raised ? { egress, irreversible: raised && !shell, ...(shell ? { shell: true } : {}) } : undefined;
 }
-export const PERMISSION_MODES = ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
+export const PERMISSION_MODES = Object.freeze(["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"]);
 const PERMISSION_MODE_SET = new Set(PERMISSION_MODES);
 export function isPermissionMode(v) {
     return PERMISSION_MODE_SET.has(v);
@@ -166,7 +166,7 @@ export function clampPermissionMode(declared, ceiling) {
         return { effective: ceiling, clamped: true };
     return PERMISSION_MODE_RANK[declared] <= PERMISSION_MODE_RANK[ceiling] ? { effective: declared, clamped: false } : { effective: ceiling, clamped: true };
 }
-export const ASK_CLASSES = [
+export const ASK_CLASSES = Object.freeze([
     "content_question",
     "hook",
     "ancestor",
@@ -187,7 +187,7 @@ export const ASK_CLASSES = [
     "artifact_shared_read",
     "mode",
     "ordinary",
-];
+]);
 const ASK_CLASS_SET = new Set(ASK_CLASSES);
 export function isAskClass(v) {
     return ASK_CLASS_SET.has(v);
@@ -216,7 +216,7 @@ export const MODE_ARBITRATION = {
 };
 export const RRA_EXPLAINERS = new Set(["unverifiable_delete", "transcript_write", "org_rule", "governance_unavailable", "rule_unreadable", "denial_limit_fallback", "ancestor", "artifact_shared_read"]);
 export const RELEASABLE_ASK_CLASSES = ASK_CLASSES.filter((c) => !MODE_ARBITRATION[c].bypassImmune);
-export const MODE_RELEASE_REASONS = ["rule_unreadable"];
+export const MODE_RELEASE_REASONS = Object.freeze(["rule_unreadable"]);
 const MODE_RELEASE_REASON_SET = new Set(MODE_RELEASE_REASONS);
 export function isModeReleaseReason(v) {
     return MODE_RELEASE_REASON_SET.has(v);

package/dist/core/ask-unresolvable-notice.js

@@ -1,4 +1,4 @@
-export const ASK_UNRESOLVABLE_CAUSES = ["approver_unavailable", "no_approver_wired", "mandate_unreconstructible"];
+export const ASK_UNRESOLVABLE_CAUSES = Object.freeze(["approver_unavailable", "no_approver_wired", "mandate_unreconstructible"]);
 Object.freeze(ASK_UNRESOLVABLE_CAUSES);
 const ASK_UNRESOLVABLE_CAUSE_SET = new Set(ASK_UNRESOLVABLE_CAUSES);
 export function isAskUnresolvableCause(v) {

package/dist/core/auto-mode.js

@@ -1,22 +1,22 @@
 import { AUTO_MODE_DEFAULT_TIMEOUT_MS, AUTO_MODE_DENIAL_AUTO_DENY_DEFAULT_MS, AUTO_MODE_DENIAL_LIMIT_DEFAULTS } from "./auto-mode-defaults.js";
 import { thrownIs } from "./thrown-value.js";
 import { describeRejectedValue } from "./tool-search-setting.js";
-export const AUTO_MODE_UNAVAILABLE_CAUSES = ["error", "timeout"];
+export const AUTO_MODE_UNAVAILABLE_CAUSES = Object.freeze(["error", "timeout"]);
 const AUTO_MODE_UNAVAILABLE_CAUSE_SET = new Set(AUTO_MODE_UNAVAILABLE_CAUSES);
 export function isAutoModeUnavailableCause(v) {
     return AUTO_MODE_UNAVAILABLE_CAUSE_SET.has(v);
 }
-export const AUTO_MODE_PARSE_FAILURES = ["missing", "conflict"];
+export const AUTO_MODE_PARSE_FAILURES = Object.freeze(["missing", "conflict"]);
 const AUTO_MODE_PARSE_FAILURE_SET = new Set(AUTO_MODE_PARSE_FAILURES);
 export function isAutoModeParseFailure(v) {
     return AUTO_MODE_PARSE_FAILURE_SET.has(v);
 }
-export const AUTO_MODE_FALLBACK_CAUSES = ["error", "timeout", "parse_error"];
+export const AUTO_MODE_FALLBACK_CAUSES = Object.freeze(["error", "timeout", "parse_error"]);
 const AUTO_MODE_FALLBACK_CAUSE_SET = new Set(AUTO_MODE_FALLBACK_CAUSES);
 export function isAutoModeFallbackCause(v) {
     return AUTO_MODE_FALLBACK_CAUSE_SET.has(v);
 }
-export const AUTO_MODE_CLASSIFIER_FALLBACKS = ["main", "none"];
+export const AUTO_MODE_CLASSIFIER_FALLBACKS = Object.freeze(["main", "none"]);
 const AUTO_MODE_CLASSIFIER_FALLBACK_SET = new Set(AUTO_MODE_CLASSIFIER_FALLBACKS);
 export function isAutoModeClassifierFallback(v) {
     return AUTO_MODE_CLASSIFIER_FALLBACK_SET.has(v);

package/dist/core/background-agent-store.js

@@ -1,6 +1,6 @@
 import { uuidv7 } from "../internal/harness.js";
 import { assertRetentionPolicy } from "./retention-policy.js";
-export const REVIVED_ROW_CLEARED_FIELDS = [
+export const REVIVED_ROW_CLEARED_FIELDS = Object.freeze([
     "settledAt",
     "stoppedBy",
     "completionId",
@@ -16,7 +16,7 @@ export const REVIVED_ROW_CLEARED_FIELDS = [
     "recentSteps",
     "editedFiles",
     "usage",
-];
+]);
 export function clearRevivedRowTerminalPayload(record) {
     for (const field of REVIVED_ROW_CLEARED_FIELDS)
         delete record[field];

package/dist/core/checkpoint-execution-record.js

@@ -1,5 +1,5 @@
 import {} from "./ask-origin.js";
-export const EXECUTION_OUTCOME_RECORD_WORDS = ["recorded", "already_recorded", "not_resolved", "absent"];
+export const EXECUTION_OUTCOME_RECORD_WORDS = Object.freeze(["recorded", "already_recorded", "not_resolved", "absent"]);
 export const EXECUTION_RECORD_LEAVES_ROW_UNRECORDED = {
     recorded: false,
     already_recorded: false,

package/dist/core/checkpoint-store.d.ts

@@ -1135,7 +1135,7 @@ export interface CheckpointState {
          *  revive the mode where the redeeming deployment denies it, and an `auto` row arms only where a face is
          *  wired. Absent on a task that declared nothing and inherited nothing (`default`). Rows written before this
          *  member carried `autoModeRequested` / `approverPosture` / a doctrine `shellGate`; the resume leg migrates
-         *  them once, announced (`resume.legacy_mode_seed_migrated`), and the next suspend writes this member. The migration is kept through 7.37.x and removed in 7.38.0, which refuses a row still carrying these keys. */
+         *  them once, announced (`resume.legacy_mode_seed_migrated`), and the next suspend writes this member. The migration is kept through 7.38.x and removed in 7.39.0, which refuses a row still carrying these keys. */
         permissionMode?: PermissionMode;
         /** Beside a recorded `plan`: the declared word the leg had when a steer or the model's `EnterPlanMode` moved it into
          *  plan — the mode an approved or edited `plan_review` resumes under ({@link import("./mode-policy.js").modeRequestAfterResume}). */
@@ -3055,6 +3055,6 @@ export interface LegacyModeSeedMigration {
  *  - `shellGate`: absent ⇒ none; `"always"` ⇒ kept (a live key, not a retired encoding); `"off"` / `"classify"` ⇒
  *    dropped (no floor); anything else ⇒ refused (`resume.legacy_mode_seed`).
  * Idempotent: a row the resume leg writes back carries `permissionMode` and the floor only, so a second read migrates nothing ("once" is per row).
- * Migration precedes any retired-key door, so a window row is read rather than refused. The window: this migration is kept through 7.37.x and removed in 7.38.0, which refuses a row still carrying these keys — resume or abandon a row parked before 7.34.0 before upgrading to 7.38.0.
+ * Migration precedes any retired-key door, so a window row is read rather than refused. The window: this migration is kept through 7.38.x and removed in 7.39.0, which refuses a row still carrying these keys — resume or abandon a row parked before 7.34.0 before upgrading to 7.39.0.
  */
 export declare function migrateLegacyModeSeed(gate: object | undefined): LegacyModeSeedMigration;

package/dist/core/checkpoint-store.js

@@ -74,7 +74,7 @@ const BIDI_BACKFILL_MAX_NODES = 512;
 export const MAX_PENDING_STEER_CHARS = 16_000;
 export const PENDING_STEER_QUEUE_BYTE_BUDGET_BYTES = 48_000;
 export const MAX_PENDING_STEER_ENTRIES = Math.floor(PENDING_STEER_QUEUE_BYTE_BUDGET_BYTES / MAX_PENDING_STEER_CHARS);
-export const PENDING_STEER_FROZEN_FIELDS = ["text", "trusted", "actor", "seq", "inputId", "priority"];
+export const PENDING_STEER_FROZEN_FIELDS = Object.freeze(["text", "trusted", "actor", "seq", "inputId", "priority"]);
 export function isPlainRecord(x) {
     try {
         if (x === null || typeof x !== "object" || Array.isArray(x))
@@ -500,7 +500,7 @@ export function validatePendingSteer(steer) {
 }
 export const MAX_ACTOR_FIELD_CHARS = 256;
 export const MAX_STEER_INPUT_ID_CHARS = 128;
-export const ACTOR_ASSERTION_FROZEN_FIELDS = ["id", "hostAsserted", "issuer"];
+export const ACTOR_ASSERTION_FROZEN_FIELDS = Object.freeze(["id", "hostAsserted", "issuer"]);
 function captureActorAssertion(actor) {
     if (actor === null || typeof actor !== "object") {
         throw new CheckpointError("steering.invalid_content", `actor must be an object carrying the attribution fields (got ${actor === null ? "null" : typeof actor})`);

package/dist/core/child-clamp-seats.js

@@ -1,4 +1,4 @@
-export const CHILD_CLAMP_SEATS = ["handsReadOnly", "interactiveTools", "readFace", "writeFace", "readDenyPatterns"];
+export const CHILD_CLAMP_SEATS = Object.freeze(["handsReadOnly", "interactiveTools", "readFace", "writeFace", "readDenyPatterns"]);
 export const CHILD_CLAMP_SEATS_NOT_CARRIED = Object.freeze({
     toolPolicy: "not a clamp a child spec copies: a parent's denies reach its children through the ancestor-constraint chain the child's own prepare folds, not by putting the parent's policy object on the child seat",
     shellGate: "travels on the inherited-gate lane (`InheritedGate.shellGate`, a trusted internals seat), not on the child spec — a spec-level copy would be a second source for the same clamp",
@@ -8,7 +8,7 @@ export const CHILD_CLAMP_SEATS_NOT_CARRIED = Object.freeze({
     excludeTools: "roster control rather than containment: the lanes that copy a parent's roster do so beside these seats, and the workflow lane authors its child roster from the governance baseline instead of the host's",
     deferTools: "roster control, same reading as `excludeTools` above",
 });
-export const ENGINE_CHILD_SPEC_CONSTRUCTORS = [
+export const ENGINE_CHILD_SPEC_CONSTRUCTORS = Object.freeze([
     "src/agents/subagent.ts#buildChildSpec",
     "src/agents/subagent.ts#observerSpec",
     "src/agents/subagent.ts#resumeSpec",
@@ -16,7 +16,7 @@ export const ENGINE_CHILD_SPEC_CONSTRUCTORS = [
     "src/agents/verify.ts#verifierSpec",
     "src/agents/verify.ts#fixLegSpec",
     "src/orchestration/workflow-primitives.ts#workflowChildClamps",
-];
+]);
 export function childClampSeats(source) {
     return {
         ...(source.handsReadOnly === true ? { handsReadOnly: true } : {}),

package/dist/core/compliance.js

@@ -1,4 +1,4 @@
-export const COMPLIANCE_CAPABILITIES = ["mcp_servers", "workflows", "web_fetch", "org_memory_mount"];
+export const COMPLIANCE_CAPABILITIES = Object.freeze(["mcp_servers", "workflows", "web_fetch", "org_memory_mount"]);
 export const BUILTIN_COMPLIANCE_DENIES = {
     hipaa: ["web_fetch", "org_memory_mount"],
     zdr: ["org_memory_mount"],

package/dist/core/context-edit.js

@@ -33,7 +33,7 @@ export const COMPACTION_TRIGGER_BUFFER_TOKENS = 13000;
 export function contextEditFrontier(window) {
     return Math.max(window - (CONTEXT_OUTPUT_RESERVE_TOKENS + COMPACTION_TRIGGER_BUFFER_TOKENS), Math.floor(window * EDIT_FRACTION));
 }
-export const MICRO_COMPACT_MACHINES = ["off", "cc"];
+export const MICRO_COMPACT_MACHINES = Object.freeze(["off", "cc"]);
 export const CC_DEFAULT_KEEP_RECENT_TOOL_RESULTS = 5;
 export const MIN_CLEAR_SAVINGS_TOKENS = 20000;
 const MEDIA_BLOCK_SAVINGS_TOKENS = 2000;