@sema-agent/core 7.23.5 → 7.24.0

package/dist/core/runner/run-turn-boundary.js

@@ -1,7 +1,7 @@
 import { mintSystemReminder } from "../reminder-mint.js";
 import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { redactThenCut } from "../../agents/subagent-steps.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, attachmentEnvelopeTags, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, isIntactSource, rebaseCadenceWindows, renderAgentListingFrame, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
@@ -643,22 +643,7 @@ export function createTurnBoundary(input) {
             }
             recordCompactionReuse(runner, prepared, comp);
             if (comp.compacted) {
-                queue.push({
-                    type: "compacted",
-                    trigger: passTrigger,
-                    tokensBefore: comp.tokensBefore ?? 0,
-                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                    ...(comp.modelFallback ? { modelFallback: true } : {}),
-                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                    ...ident(),
-                });
+                queue.push(mintCompactedEvent(comp, passTrigger, ident()));
                 if (!forceManual && recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
                     compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
                     queue.push({ type: "compaction_outcome", outcome: "disabled", trigger: passTrigger, reason: "rapid_refill: compaction disabled for the rest of this task", ...ident() });
@@ -674,9 +659,8 @@ export function createTurnBoundary(input) {
                     rs.attach.attachState.postCompactPending = true;
                     rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
                 }
-                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                    const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                    rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON && comp.postTriggerTokens !== undefined) {
+                    rs.counters.compactionFloor = Math.ceil(comp.postTriggerTokens * COMPACTION_REGROWTH_FACTOR);
                 }
             }
         }

package/dist/core/runner/runtask.js

@@ -6,7 +6,7 @@ import { createRapidRefillState } from "../auto-compaction.js";
 import { boundInputHashOf } from "../canonical-json.js";
 import { emitTrace } from "../trace.js";
 import { emitTaskOutcome } from "../task-outcome.js";
-import { authCarrierFingerprint, normalizeBaseUrl } from "../../brain/route-adjudicator.js";
+import { authCarrierFingerprint, displayUrlOf, routeKeyOf } from "../../brain/route-adjudicator.js";
 import { runWithReasoningWireFacts } from "../../brain/status-sink.js";
 import { expandTiers } from "../roles.js";
 import { screenSwappableDeps } from "../swappable-deps.js";
@@ -208,10 +208,8 @@ export class Runner {
                 const prior = this.deps.models?.[name];
                 if (!prior)
                     continue;
-                const from = normalizeBaseUrl(prior.baseUrl);
-                const to = normalizeBaseUrl(nextModel.baseUrl);
-                if (from !== to && authCarrierFingerprint(prior.headers) === authCarrierFingerprint(nextModel.headers)) {
-                    movedEntries.push({ modelId: name, from, to });
+                if (routeKeyOf(prior.baseUrl) !== routeKeyOf(nextModel.baseUrl) && authCarrierFingerprint(prior.headers) === authCarrierFingerprint(nextModel.headers)) {
+                    movedEntries.push({ modelId: name, from: displayUrlOf(prior.baseUrl), to: displayUrlOf(nextModel.baseUrl) });
                 }
             }
         }

package/dist/core/runner/stream-settle-backstop.js

@@ -6,7 +6,7 @@ import { createSafeNotifier } from "../safe-notify.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { emitTrace } from "../trace.js";
 import { deliverDelegationLifecycle } from "../types.js";
-import { asThrownError, thrownText } from "../thrown-value.js";
+import { asThrownError, readMember, thrownText } from "../thrown-value.js";
 export function streamSettleBackstop(input) {
     const { spec, resume, queue, taskIdRef, entryTracer, runStartedAt, live, runner, sessions, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
     const onRunRejected = async (err) => {
@@ -57,11 +57,11 @@ export function streamSettleBackstop(input) {
         }
         const remoteEnvFailure = (() => {
             let cur = err;
-            for (let depth = 0; cur && typeof cur === "object" && depth < 8; depth++) {
-                const note = cur.remoteEnvFailure;
+            for (let depth = 0; cur !== null && cur !== undefined && typeof cur === "object" && depth < 8; depth++) {
+                const note = readMember(cur, "remoteEnvFailure");
                 if (note !== undefined)
                     return [note];
-                cur = cur.cause;
+                cur = readMember(cur, "cause");
             }
             return undefined;
         })();
@@ -79,7 +79,7 @@ export function streamSettleBackstop(input) {
                 return observed !== undefined && observed.length > 0 ? { editedFiles: observed } : {};
             })(),
             ...(() => {
-                const hinted = err.retryAfterMs;
+                const hinted = readMember(err, "retryAfterMs");
                 return code === "memory.admission_required" && typeof hinted === "number" && Number.isFinite(hinted) && hinted > 0
                     ? { retryAfterMs: hinted }
                     : {};

package/dist/core/runner/tool-end-body.js

@@ -1,4 +1,5 @@
 import {} from "../../internal/harness.js";
+import { readMember } from "../thrown-value.js";
 import { MCP_DELIVERY_VERDICTS } from "../mcp-failure.js";
 import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
 import { toolOutputFrom } from "./tool-output-projection.js";
@@ -35,11 +36,11 @@ export function batchResponseDigest(result) {
 export function toolEndBodyFrom(result, isError, structured, gate, gatedCallIdOfRun) {
     const o = toolOutputFrom(result);
     const st = structured(result);
-    const det = isError ? result?.details : undefined;
-    const codeRaw = det?.code;
-    const kindRaw = det?.errorKind;
+    const det = isError ? readMember(result, "details") : undefined;
+    const codeRaw = readMember(det, "code");
+    const kindRaw = readMember(det, "errorKind");
     const code = typeof codeRaw === "string" ? codeRaw : typeof kindRaw === "string" ? kindRaw : undefined;
-    const deliveredRaw = det?.delivered;
+    const deliveredRaw = readMember(det, "delivered");
     const delivered = typeof deliveredRaw === "string" && MCP_DELIVERY_VERDICTS.includes(deliveredRaw) ? deliveredRaw : undefined;
     const gatedCallId = code === "gate.parked" ? gatedCallIdOfRun : undefined;
     return {

package/dist/core/runner/tool-output-projection.js

@@ -1,4 +1,5 @@
 import { engineCardTypes } from "../tool-registry.js";
+import { readMember } from "../thrown-value.js";
 const MAX_TOOL_END_OUTPUT_CHARS = 16384;
 const safeJsonLength = (v) => {
     try {
@@ -62,10 +63,10 @@ export function createStructuredProjector(opts = {}) {
     const allowed = new Set([...CC_DETAIL_TYPES, ...(opts.declaredCards ?? [])]);
     const announced = new Set();
     return (result) => {
-        const details = result !== null && typeof result === "object" ? result.details : undefined;
+        const details = readMember(result, "details");
         if (details === null || typeof details !== "object")
             return undefined;
-        const t = details.type;
+        const t = readMember(details, "type");
         if (typeof t !== "string")
             return undefined;
         if (!allowed.has(t)) {

package/dist/core/runner/turn-attachments.d.ts

@@ -346,26 +346,6 @@ export declare const INSTRUCTIONS_CHANGE_BYTE_CAP = 512;
  * `steering_injected` echo are all keyed on that wordlist.
  */
 export declare function createAttachmentState(): AttachmentState;
-/**
- * H4 — thin-projection reducer over a tool's RAW `result.details` (NOT the wire card projector
- * projection and its 4×16K caps: a huge todo list must shrink into a bounded snapshot here, never
- * disarm the reminder by being dropped wholesale). Only the first-party discriminants `todo` /
- * `task` / `task-list` are recognized — every other card type (subagent `agent`/`fork`/`task-output`,
- * bash, fs, mcp, …) is structurally ignored, which is also the child-isolation contract: a subagent's
- * own todo state never reaches the parent's onToolEnd, and its delegation-card types don't parse here.
- *
- * task #51 F3 (窗口复位/投影摄入拆分): this reducer is PROJECTION INGEST ONLY — it
- * never touches the write windows. CC's window anchor is the tool_use block's PRESENCE in the
- * transcript (qFm/BFm match the block by name, :480217-480219/:480253-480254, with no execution-
- * outcome check), so the run loop stamps the windows on INITIATION via {@link stampWriteAnchor}
- * (inside {@link advanceCadenceClock}'s message walk); ingest stays success-only — a failed write
- * has no trustworthy `details`, exactly like CC's reminder body rendering from the authoritative
- * store rather than from tool results.
- *
- * Idempotent (same event twice ⇒ same state) and commutative across DISTINCT task ids (F10); two
- * whole-list writes (TodoWrite / TaskList) racing in one batch are last-write-wins by nature — the
- * later list IS the truer snapshot, documented rather than fought.
- */
 export declare function reduceToolEnd(state: AttachmentState, details: unknown): void;
 /** task #51 F2/F3 — which reminder window a tool_use block resets. Resolved by the run loop (alias-aware:
  *  ToolSpec.aliases over the mounted roster; retired-name normalization is gone); the producers

package/dist/core/runner/turn-attachments.js

@@ -1,4 +1,5 @@
 import { PRESENT_PLAN_TOOL_NAME } from "../present-plan-tool.js";
+import { readMember } from "../thrown-value.js";
 import { delimitUntrustedWithClip, sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
 import { protocolOf } from "../protocol-table.js";
 import { renderSkillLinesWithin, renderSkillsBlock } from "./synthetic-tools.js";
@@ -24,6 +25,7 @@ export const CHANGED_FILES_MAX = 20;
 export const CHANGED_FILES_MTIME_EPS_MS = 2000;
 export const ATTACHMENT_BYTE_CAP = 8 * 1024;
 const PROJECTION_ITEMS_MAX = 50;
+const PROJECTION_SCAN_MAX = 10_000;
 const PROJECTION_CONTENT_MAX = 80;
 const LISTING_FRAME_FLOOR_BYTES = 768;
 const DATE_CHANGE_MAX_BYTES = 160;
@@ -72,52 +74,55 @@ export function createAttachmentState() {
         postCompactPending: false,
     };
 }
+function readListLength(value) {
+    const n = value !== null && typeof value === "object" ? readMember(value, "length") : undefined;
+    return typeof n === "number" && Number.isInteger(n) && n >= 0 ? Math.min(n, PROJECTION_SCAN_MAX) : undefined;
+}
+function readTaskEntry(raw) {
+    const id = readMember(raw, "id");
+    if (typeof id !== "string")
+        return undefined;
+    const subject = readMember(raw, "subject");
+    const status = readMember(raw, "status");
+    return { id, item: { content: typeof subject === "string" ? subject.slice(0, PROJECTION_CONTENT_MAX) : "", status: typeof status === "string" ? status : "pending" } };
+}
 export function reduceToolEnd(state, details) {
-    if (details === null || typeof details !== "object")
-        return;
-    const d = details;
-    if (d.type === "todo") {
-        const newTodos = d.newTodos;
-        if (!Array.isArray(newTodos))
+    const type = readMember(details, "type");
+    if (type === "todo") {
+        const newTodos = readMember(details, "newTodos");
+        const count = readListLength(newTodos);
+        if (count === undefined)
             return;
-        const shaped = newTodos.flatMap((t) => {
-            const item = t;
-            return item && typeof item === "object" && typeof item.content === "string" && typeof item.status === "string"
-                ? [{ content: item.content.slice(0, PROJECTION_CONTENT_MAX), status: item.status }]
-                : [];
-        });
+        const shaped = [];
+        for (let i = 0; i < count; i++) {
+            const item = readMember(newTodos, String(i));
+            const content = readMember(item, "content");
+            const status = readMember(item, "status");
+            if (typeof content === "string" && typeof status === "string")
+                shaped.push({ content: content.slice(0, PROJECTION_CONTENT_MAX), status });
+        }
         const allDone = shaped.length > 0 && shaped.every((t) => t.status === "completed");
         state.todo = allDone ? { items: [] } : { items: shaped.slice(0, PROJECTION_ITEMS_MAX) };
     }
-    else if (d.type === "task") {
+    else if (type === "task") {
         const map = state.taskItems ?? (state.taskItems = new Map());
-        const deleted = d.deleted;
+        const deleted = readMember(details, "deleted");
         if (typeof deleted === "string")
             map.delete(deleted);
-        const task = d.task;
-        if (task !== null && typeof task === "object") {
-            const t = task;
-            if (typeof t.id === "string") {
-                map.set(t.id, {
-                    content: typeof t.subject === "string" ? t.subject.slice(0, PROJECTION_CONTENT_MAX) : "",
-                    status: typeof t.status === "string" ? t.status : "pending",
-                });
-            }
-        }
-    }
-    else if (d.type === "task-list") {
-        const tasks = d.tasks;
-        if (!Array.isArray(tasks))
+        const entry = readTaskEntry(readMember(details, "task"));
+        if (entry !== undefined)
+            map.set(entry.id, entry.item);
+    }
+    else if (type === "task-list") {
+        const tasks = readMember(details, "tasks");
+        const count = readListLength(tasks);
+        if (count === undefined)
             return;
         const map = new Map();
-        for (const raw of tasks) {
-            const t = raw;
-            if (t && typeof t === "object" && typeof t.id === "string") {
-                map.set(t.id, {
-                    content: typeof t.subject === "string" ? t.subject.slice(0, PROJECTION_CONTENT_MAX) : "",
-                    status: typeof t.status === "string" ? t.status : "pending",
-                });
-            }
+        for (let i = 0; i < count; i++) {
+            const entry = readTaskEntry(readMember(tasks, String(i)));
+            if (entry !== undefined)
+                map.set(entry.id, entry.item);
         }
         state.taskItems = map;
     }

package/dist/core/session-store.js

@@ -1,5 +1,6 @@
 import { InMemorySessionRepo, SessionError, uuidv7, } from "../internal/harness.js";
 import { isSessionConflict } from "./session.js";
+import { readMember } from "./thrown-value.js";
 const DAY_MS = 24 * 60 * 60 * 1000;
 import { SESSION_DEFAULT_TTL_DAYS } from "../config/defaults.js";
 export { SESSION_DEFAULT_TTL_DAYS };
@@ -285,8 +286,5 @@ async function settledForkOptions(source) {
     return {};
 }
 function isNotFound(err) {
-    return (typeof err === "object" &&
-        err !== null &&
-        "code" in err &&
-        err.code === "not_found");
+    return readMember(err, "code") === "not_found";
 }

package/dist/core/session.d.ts

@@ -8,7 +8,10 @@ export type { SessionWriteOptions } from "../internal/harness.js";
 import type { Session } from "../internal/harness.js";
 import type { SessionTreeEntry } from "../internal/harness.js";
 export type { SessionPlacementRecord } from "../internal/harness.js";
-/** True when `err` is a session optimistic-lock conflict (a concurrent writer won the branch leaf). */
+/** True when `err` is a session optimistic-lock conflict (a concurrent writer won the branch leaf). Both
+ *  halves read what a HOST `SessionStorage` threw, so both are guarded — unreadable is not a conflict,
+ *  never a raise inside the classify-and-rethrow guard. The class test is KEPT: widening the verdict to
+ *  any value carrying the word would arm the CAS retry loop on a foreign error (KL-942b). */
 export declare function isSessionConflict(err: unknown): boolean;
 /**
  * Subagent transcript persistence — the ACQUIRE-form placement declaration a trusted spawner passes

package/dist/core/session.js

@@ -3,8 +3,9 @@ export { InMemorySessionRepo, InMemorySessionStorage, uuidv7, validateEntriesFor
 export { BaseSessionStorage, leafIdAfterEntry, } from "../internal/harness.js";
 export { SessionError } from "../internal/harness.js";
 import { SessionError } from "../internal/harness.js";
+import { readMember, thrownIs } from "./thrown-value.js";
 export function isSessionConflict(err) {
-    return err instanceof SessionError && err.code === "conflict";
+    return thrownIs(err, SessionError) && readMember(err, "code") === "conflict";
 }
 export function hasSessionFork(store) {
     return typeof store.fork === "function";

package/dist/core/task-event.d.ts

@@ -592,16 +592,23 @@ export type TaskEvent = ({
     type: "compacted";
     trigger: "auto" | "manual" | "forced";
     tokensBefore: number;
-    /** TB telemetry B4: post-compaction context size in the TRIGGER-GATE coordinate
-     *  (`postTriggerTokens` = estimate + anchor-less overhead). Pairs with {@link triggerTokensBefore}
-     *  — NOT with `tokensBefore` (which is the CC `pre_tokens` value in prepareCompaction's coordinate,
-     *  lacking the overhead term; subtracting across the two coordinates would mis-state the delta,
-     *  the audit-B-1 / P-13 class). Absent when the post measurement failed (best-effort, never fails a
-     *  successful compaction). */
+    /** How much context this compaction FREED, as the engine measured it: one structural sum over
+     *  the pre-messages minus the same sum over the post-messages, inside the pass. **The only
+     *  subtractable number on this event**, and what a context meter should render. Clamped ≥ 0 at
+     *  the mint, so `0` means "freed nothing", never "could not tell". Absent ⇒ the post
+     *  measurement failed and no delta exists — never a stand-in. */
+    freedTokens?: number;
+    /** DIAGNOSTIC, NOT subtractable. Post-compaction size in the TRIGGER-GATE coordinate
+     *  (structural estimate + the fixed prompt overhead). {@link triggerTokensBefore} is not its
+     *  matching pre-value: the gate reads a usage-ANCHORED figure whenever the provider's last
+     *  usage is fresh, while this is always structural + overhead, so the difference mixes
+     *  coordinates and goes NEGATIVE on ordinary auto passes (3037 − 4591 = −1554, measured on a
+     *  4k window). Use {@link freedTokens}. Absent when the post measurement failed. */
     tokensAfter?: number;
-    /** TB telemetry B4: pre-compaction size in the SAME trigger-gate coordinate as {@link tokensAfter}
-     *  (`triggerTokens` — the exact quantity the compaction gate compared). `triggerTokensBefore −
-     *  tokensAfter` is the self-consistent freed delta. Absent on the legacy emitter. */
+    /** DIAGNOSTIC, NOT subtractable. The quantity the gate compared against its threshold —
+     *  usage-anchored when the anchor is fresh, structural + overhead when it is not. It answers
+     *  WHAT tripped the trigger, a different question from how much was freed; left un-clamped and
+     *  un-paired rather than made to look subtractable. Absent on the legacy emitter. */
     triggerTokensBefore?: number;
     /** TB telemetry B4: wall time of the whole compaction pass (summary call included) — what the
      *  boundary pause actually cost. Absent on legacy emitters. */
@@ -823,6 +830,9 @@ export type TaskEvent = ({
      * Live/ephemeral — NOT persisted (a resumable trace re-derives usage from the result), like `status`.
      * Maps to CC `SDKTaskProgress` (camelCase here → snake_case `task_id`/`total_tokens`/`tool_uses`/`duration_ms`
      * at the SDK/service projection, the same convention as `toolCallId`→`tool_use_id`).
+     * `taskId` is the child RUN's id (`spec.taskId ?? sessionId`), NOT the registry handle: the
+     * background lanes launch with no explicit `spec.taskId`, so it equals the child's session id and
+     * hence its `transcriptId`. Both domains are tabled in `docs/INTEGRATION-CORE.md` §1.6a.
      */
     type: "task_progress";
     taskId: string;

package/dist/core/task-registry-shared.js

@@ -227,6 +227,7 @@ export function formatWorkflowRun(run) {
                 : {}),
             ...(run.journalSkips !== undefined && run.journalSkips > 0 ? { journal_skipped: run.journalSkips } : {}),
             ...(run.status === "failed" && run.error ? { error: delimitUntrusted("workflow error", boundedRedactedSummary(run.error, 500)) } : {}),
+            ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
             ...(run.status === "completed" && run.result !== undefined
                 ? { result: delimitUntrusted("workflow result", run.resultFull ?? run.result) }
                 : {}),

package/dist/core/thrown-value.d.ts

@@ -1,8 +1,8 @@
 /**
  * Is this an Error, including one minted in ANOTHER REALM?
  *
- * `instanceof` compares against THIS realm's `Error.prototype`, so a genuine `Error` thrown by a script the
- * engine ran inside `vm.createContext` — a workflow script is exactly that — fails the test and would be
+ * `instanceof` compares against THIS realm's `Error.prototype`, so a genuine `Error` minted outside it — by
+ * a script the engine ran through a deployment-supplied runner, or a duplicated module instance — fails and would be
  * described as an anonymous object, losing the message that is the entire point of reporting it. The brand
  * check is the realm-independent one: an object with the `[[ErrorData]]` internal slot answers `[object Error]`
  * no matter where it was made, and a proxy forwards it. A plain object can forge the tag through
@@ -13,21 +13,28 @@
  * proxy traps, and the tag is a getter that can throw.
  */
 export declare function isErrorLike(value: unknown): boolean;
+/** `value instanceof ctor`, TOTAL — the class half of {@link readMember}'s rule. The prototype-chain walk
+ *  runs two proxy traps and a revoked proxy throws on both, while every caller tests a value someone else
+ *  threw inside the handler that decides how a failure settles. Unrecognizable is not that class, and
+ *  {@link isErrorLike} is this same rule for `Error`. */
+export declare function thrownIs<T>(value: unknown, ctor: abstract new (...args: never[]) => T): value is T;
+/** The NAME a thrown value carries (`Error.prototype.name` and its subclasses' overrides), read
+ *  realm-independently and guarded — `undefined` when the value is not error-like or its `name` is not a
+ *  string. Callers that compare against a name CONSTANT need exactly this: the comparison is on the WORD
+ *  precisely because the value crossed a seam, so binding the test to this realm's `Error.prototype`
+ *  defeats it. Whether an EMPTY name folds to `undefined` is policy and stays at the call site. */
+export declare function thrownName(err: unknown): string | undefined;
 /**
  * Turning a value that was THROWN at us into text — the ONE rule, for the whole engine.
  *
- * The idiom this replaces is `err instanceof Error ? err.message : String(err)` (and its template-literal
- * twin, `` `${err}` ``). Both spell a PARTIAL function on the non-Error arm: `String` calls the value's own
- * `toString` / `Symbol.toPrimitive`, so it throws on a value that has neither (a null-prototype object) and
- * on one whose own hook throws. The thrower is not ours — a deployment hook, a plugin callback, a model-
- * supplied tool body may reject with any value at all — so the rendering step was the one step that could
- * destroy the report it exists to produce. Where the render sat inside a promise rejection handler, the
- * resulting `TypeError` was an unhandled rejection and took the whole process down: a caller's choice of
- * rejection value decided whether the engine stayed alive.
+ * The idiom it replaces — `err instanceof Error ? err.message : String(err)` — is PARTIAL on its non-Error
+ * arm: `String` calls the value's own `toString` / `Symbol.toPrimitive`, so it throws on a value that has
+ * neither and on one whose hook throws. The thrower is not ours (a deployment hook, a plugin callback, a
+ * model-supplied tool body may reject with anything), so the rendering step was the one step that could
+ * destroy the report it exists to produce — and inside a promise rejection handler it took the process down.
  *
- * Totality is therefore the contract, and it is met the same way the engine's structural describer already
- * meets it: the value is never asked to say what it is. Three arms, in this order, chosen so that the
- * dominant shapes keep their EXACT previous bytes and only the shapes that used to be useless or fatal move:
+ * TOTALITY is therefore the contract, met the way the structural describer meets it: the value is never
+ * asked to say what it is. Three arms, ordered so the dominant shapes keep their EXACT previous bytes:
  *  - a thrown STRING is its own message (a bare `throw "…"`), returned verbatim — the describer would quote
  *    it, which is right when rejecting a config value and wrong when relaying a message someone threw;
  *  - an ERROR hands over `message` verbatim — no cap, no one-lining, no quoting. This is the arm nearly all
@@ -90,6 +97,10 @@ export declare function asThrownError(err: unknown): Error;
  * is `undefined` for BOTH "absent" and "unreadable" — deliberately, because a caller that must tell those
  * apart is asking a question an untrusted value is not obliged to answer; what it does instead is fall back
  * to describing the value, which {@link thrownText} already does totally.
+ *
+ * The read walks the PROTOTYPE CHAIN deliberately — `name` lives on `Error.prototype`. `"__proto__"` is
+ * the one key where that differs from an own read, and its only caller is {@link readOwnMembers}, which
+ * passes it only when it IS an own key (a data property shadows the accessor; both readings agree).
  */
 export declare function readMember(value: unknown, key: string): unknown;
 /** The PLURAL of {@link readMember}: read a value's own enumerable members, once each, into an inert

package/dist/core/thrown-value.js

@@ -9,6 +9,18 @@ export function isErrorLike(value) {
         return false;
     }
 }
+export function thrownIs(value, ctor) {
+    try {
+        return value instanceof ctor;
+    }
+    catch {
+        return false;
+    }
+}
+export function thrownName(err) {
+    const name = isErrorLike(err) ? readMember(err, "name") : undefined;
+    return typeof name === "string" ? name : undefined;
+}
 export function thrownText(err) {
     try {
         if (typeof err === "string")
@@ -66,7 +78,7 @@ export function readOwnMembers(value) {
     }
     const out = {};
     for (const key of keys)
-        out[key] = readMember(value, key);
+        Object.defineProperty(out, key, { value: readMember(value, key), enumerable: true, writable: true, configurable: true });
     return out;
 }
 export function thrownMarksOf(err) {

package/dist/core/tool-errors.d.ts

@@ -33,6 +33,12 @@ export declare function truncateError(s: string): string;
  *  budget of one character. */
 export declare const OUTPUT_BUDGET_MIN_CHARS = 512;
 export declare function clipWithFilePointer(s: string, limit: number, fullOutputPath?: string): string;
+/**
+ * Format a thrown tool error into model-facing text (design/64 §11.1/§11.2): a shell/exec error becomes
+ * `Exit code N` + stderr + stdout; a plain Error becomes its message (+ any captured streams); anything
+ * else is stringified. The result is truncated to {@link MAX_ERROR_CHARS}. An AbortError is reported as an
+ * interruption.
+ */
 export declare function formatToolError(error: unknown): string;
 /**
  * A typed, read-side fold of a `TaskResult.errorCode` into the failure CLASS it belongs to (design/80

package/dist/core/tool-errors.js

@@ -2,7 +2,7 @@ import { Value } from "typebox/value";
 const MAX_ERROR_CHARS = 10_000;
 const HALF = MAX_ERROR_CHARS / 2;
 import { isHighSurrogate, isLowSurrogate, sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
-import { readMember, thrownText } from "./thrown-value.js";
+import { isErrorLike, readMember, thrownName, thrownText } from "./thrown-value.js";
 export function truncateError(s) {
     if (s.length <= MAX_ERROR_CHARS)
         return s;
@@ -39,18 +39,10 @@ function isShellLike(e) {
         return false;
     }
 }
-function isErrorInstance(v) {
-    try {
-        return v instanceof Error;
-    }
-    catch {
-        return false;
-    }
-}
 export function formatToolError(error) {
     const parts = [];
-    const name = readMember(error, "name");
-    if (isErrorInstance(error) && name === "AbortError")
+    const name = thrownName(error);
+    if (name === "AbortError")
         return "Interrupted";
     const message = readMember(error, "message");
     const messageText = typeof message === "string" ? message : undefined;
@@ -60,15 +52,15 @@ export function formatToolError(error) {
         const stdout = readMember(error, "stdout");
         if (typeof exitCode === "number")
             parts.push(`Exit code ${exitCode}`);
-        if (isErrorInstance(error) && messageText !== undefined && messageText !== "")
+        if (isErrorLike(error) && messageText !== undefined && messageText !== "")
             parts.push(messageText);
         if (typeof stderr === "string" && stderr.trim())
             parts.push(stderr);
         if (typeof stdout === "string" && stdout.trim())
             parts.push(stdout);
     }
-    else if (isErrorInstance(error)) {
-        parts.push((messageText ?? "") || (typeof name === "string" ? name : "") || "Error");
+    else if (isErrorLike(error)) {
+        parts.push((messageText ?? "") || (name ?? "") || "Error");
     }
     else {
         parts.push(thrownText(error));

package/dist/core/tools.js

@@ -6,7 +6,7 @@ function normalizeContent(ret) {
     if (typeof ret === "string") {
         return { content: [{ type: "text", text: ret }], details: undefined, terminate: false, isError: false };
     }
-    const raw = ret.content;
+    const raw = readMember(ret, "content");
     if (typeof raw !== "string" && !Array.isArray(raw)) {
         return {
             content: [{ type: "text", text: "Tool error: content must be a string or an array of content blocks." }],
@@ -16,7 +16,7 @@ function normalizeContent(ret) {
         };
     }
     const content = typeof raw === "string" ? [{ type: "text", text: raw }] : raw;
-    return { content, details: ret.details, terminate: ret.terminate ?? false, isError: ret.isError === true };
+    return { content, details: readMember(ret, "details"), terminate: readMember(ret, "terminate") === true, isError: readMember(ret, "isError") === true };
 }
 function isEmptyToolContent(content) {
     if (content.length === 0)
@@ -108,11 +108,15 @@ export function defineTool(spec, options) {
                     isError: true,
                 };
             }
-            let ret;
             try {
                 const baseCtx = { toolCallId, signal };
                 const ctx = options?.enrichCtx ? stampCallIdentity(options.enrichCtx(baseCtx), toolCallId, signal) : baseCtx;
-                ret = await spec.execute(params, ctx);
+                const ret = await spec.execute(params, ctx);
+                const { content, details, terminate, isError } = normalizeContent(ret);
+                const guarded = isEmptyToolContent(content)
+                    ? [{ type: "text", text: isError ? `(${spec.name} reported an error with no further output)` : `(${spec.name} completed with no output)` }]
+                    : content;
+                return { content: guarded, details, terminate, ...(isError ? { isError: true } : {}) };
             }
             catch (err) {
                 const wrapped = new Error(formatToolError(err));
@@ -124,11 +128,6 @@ export function defineTool(spec, options) {
                     wrapped.errorKind = errorKind;
                 throw wrapped;
             }
-            const { content, details, terminate, isError } = normalizeContent(ret);
-            const guarded = isEmptyToolContent(content)
-                ? [{ type: "text", text: isError ? `(${spec.name} reported an error with no further output)` : `(${spec.name} completed with no output)` }]
-                : content;
-            return { content: guarded, details, terminate, ...(isError ? { isError: true } : {}) };
         },
     };
     if (spec.contract) {

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

@@ -911,14 +911,14 @@ export interface RoutePairingConfig {
 export type RoutePairingPosture = "per-model" | "paired" | "unpinned" | "keyless";
 /** Machine codes an adjudication refusal carries (minted here, forwarded verbatim by consumers). */
 export type RouteRefusalCode = "route.credential_mismatch" | "route.credential_missing";
-/** The structured account of a refusal — enough for a caller to render the two halves and the fix. */
+/** The structured account of a refusal — the two halves and the fix, every URL a DISPLAY spelling. */
 export interface RouteRefusalDetail {
     modelId: string;
-    /** The entry's declared URL half (`Model.baseUrl`, normalized). */
+    /** The entry's declared URL half (`Model.baseUrl`), via `displayUrlOf` — NOT route identity. */
     entryBaseUrl: string;
-    /** The root the request would actually target (normalized). */
+    /** The root the request would actually target, rendered (use `routeKeyOf` for identity). */
     requestBaseUrl: string;
-    /** The deployment's declared root the credential is paired with (mismatch refusals). */
+    /** The declared root the credential is paired with (mismatch refusals), rendered. */
     configBaseUrl?: string;
     /** One-line configuration fix. */
     fixHint: string;

package/dist/index.d.ts

@@ -325,7 +325,7 @@ export { createCircuitBreakerBrain, type CircuitBreakerOptions, type BreakerStat
 export { createDegradingBrain, readDegradation, DEGRADED_DIAGNOSTIC_TYPE, type DegradingBrainOptions, type DegradeReason, type DegradationInfo, } from "./brain/degrading.js";
 export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { WAITING_FIRST_TOKEN_AFTER_MS, WAITING_FIRST_TOKEN_EVERY_MS } from "./brain/stream-engine.js";
-export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, normalizeBaseUrl, hasAuthCarrier, type RoutePairingStatus, } from "./brain/route-adjudicator.js";
+export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, routeKeyOf, displayUrlOf, resolveRequestRoot, hasAuthCarrier, type RoutePairingStatus, } from "./brain/route-adjudicator.js";
 export type { RouteAdjudication, RouteCredential, RouteCredentialSource, RoutePairingConfig, RoutePairingPosture, RouteRefusalCode, RouteRefusalDetail, } from "./internal/llm.js";
 export { ROUTE_ADJUDICATION_CONFORMANCE_CORPUS, type RouteAdjudicationVector } from "./brain/route-conformance.js";
 export { type BrainTimeoutConfig } from "./brain/timeout.js";