@sema-agent/core 7.54.1 → 7.56.0

package/dist/agents/tool-filter.js

@@ -3,8 +3,7 @@ import { canonicalize, UNCANONICALIZABLE } from "../core/canonical-json.js";
 import { SPAWNER_SURFACE_LEG_KINDS } from "../core/tool-face.js";
 import { ruleSpellingOf } from "../core/permission-rule-syntax.js";
 import { TOOL_CATALOG_ENTRIES } from "../core/tool-catalog-entries.js";
-import { isNamespacedCoveringRuleName, namespacedRuleNameCovers } from "../core/namespaced-rule-name.js";
-import { protocolOf } from "../core/protocol-table.js";
+import { isCoveringRuleName, ruleNameCovers, ruleNameReachIntoPeer } from "../core/namespaced-rule-name.js";
 import { splitNamespacedName } from "../core/tool-name-aliases.js";
 import { readToolNameList, snapshotToolNameList, valueTypeLabel } from "../core/tool-name-list.js";
 export function readDeniedEntry(entry) {
@@ -72,23 +71,19 @@ export function persistedToolNameList(entries, side) {
 function reachOf(entries, side) {
     const names = new Set();
     const covering = [];
-    const wholeProtocols = new Set();
     for (const entry of entries) {
         const name = toolNameOfEntry(entry, side);
         if (name === undefined)
             continue;
-        const split = splitNamespacedName(name);
-        if (split !== undefined && split.tool === undefined && split.peer === "*") {
-            if (side === "denied")
-                wholeProtocols.add(split.ns.id);
-            continue;
-        }
-        if (isNamespacedCoveringRuleName(name))
+        if (isCoveringRuleName(name, side === "denied" ? "deny" : "allow"))
             covering.push(name);
-        else
+        else if (!name.includes("*"))
             names.add(name);
     }
-    return { names, covering, wholeProtocols };
+    return { names, covering };
+}
+export function namesEveryTool(entry) {
+    return toolNameOfEntry(entry, "allowed") === "*";
 }
 export function readAllowedToolList(allowTools) {
     if (allowTools === undefined || allowTools === null)
@@ -96,7 +91,7 @@ export function readAllowedToolList(allowTools) {
     const list = readToolNameList(allowTools);
     if (list.kind !== "entries")
         return reachOf([], "allowed");
-    if (list.entries.some((entry) => toolNameOfEntry(entry, "allowed") === "*"))
+    if (list.entries.some(namesEveryTool))
         return undefined;
     return reachOf(list.entries, "allowed");
 }
@@ -109,13 +104,8 @@ export function listReaches(reach, tool) {
         if (reach.names.has(spelling))
             return true;
         for (const pattern of reach.covering)
-            if (namespacedRuleNameCovers(pattern, spelling))
+            if (ruleNameCovers(pattern, spelling))
                 return true;
-        if (reach.wholeProtocols.size > 0) {
-            const ns = protocolOf(spelling);
-            if (ns !== undefined && reach.wholeProtocols.has(ns.id))
-                return true;
-        }
     }
     return false;
 }
@@ -127,21 +117,11 @@ export function protocolToolNames(legs) {
     return [...new Set(PROTOCOL_ROWS.filter((r) => r.legs.some((l) => legs.includes(l))).map((r) => r.name))];
 }
 function reachTouchesPeer(reach, peer) {
-    if (reach.wholeProtocols.has(peer.ns))
-        return true;
-    const inPeer = (spelling) => {
-        const split = splitNamespacedName(spelling);
-        return split !== undefined && split.ns.id === peer.ns && split.peer === peer.peer;
-    };
-    return [...reach.names].some(inPeer) || reach.covering.some(inPeer);
+    const into = (spelling) => ruleNameReachIntoPeer(spelling, peer.ns, peer.peer) !== "none";
+    return [...reach.names].some(into) || reach.covering.some(into);
 }
 function reachCoversPeer(reach, peer) {
-    if (reach.wholeProtocols.has(peer.ns))
-        return true;
-    return reach.covering.some((pattern) => {
-        const split = splitNamespacedName(pattern);
-        return split !== undefined && split.ns.id === peer.ns && split.peer === peer.peer && (split.tool === undefined || split.tool === "*");
-    });
+    return reach.covering.some((pattern) => ruleNameReachIntoPeer(pattern, peer.ns, peer.peer) === "all");
 }
 export function isToolSelectorLayer(layer) {
     return typeof layer === "object" && layer !== null && !Array.isArray(layer);
@@ -166,7 +146,7 @@ export function compileToolSelector(layers, legs = []) {
             const split = splitNamespacedName(prefix);
             if (split === undefined)
                 return false;
-            const peer = { ns: split.ns.id, peer: split.peer };
+            const peer = { ns: split.ns, peer: split.peer };
             return compiled.every((l) => (l.allow === undefined || reachTouchesPeer(l.allow, peer)) && !reachCoversPeer(l.deny, peer));
         },
     });

package/dist/agents/verify.d.ts

@@ -7,13 +7,13 @@ import type { ModelRef, TaskResult, TaskSpec, TaskStatus, ToolSpec } from "../co
  * an implementation task and tries to BREAK it — read-only, evidence-required, returning a structured
  * verdict — then the gate loops fix→re-verify until PASS or a round cap.
  *
- * PROVENANCE (2026-07-14; re-verified and CORRECTED against CC 2.1.220): distilled and de-branded from the
+ * PROVENANCE (2026-07-14; re-verified and CORRECTED): distilled and de-branded from the
  * MIT-era upstream source's dedicated `verification` agent — which was an Anthropic-internal A/B experiment
- * (third-party default OFF) and has since been RETIRED upstream: 2.1.207 through 2.1.220 ship NO verification
+ * (third-party default OFF) and has since been RETIRED upstream: later releases ship NO verification
  * agent. The current upstream completion-gate shape is (a) the Stop hook (`decision:"block"` + reason fed
  * back — sema's Stop hook is at full parity) and (b) — corrected — NOT a bundled skill. There is no built-in
  * `verify` skill in the 220 corpus. What 220 ships is an INSTRUCTION TO CREATE ONE PER PROJECT: its memory
- * prompt (@190146 (cli250.js:38927)) forbids creating project skills ("never create one — a new project skill
+ * prompt forbids creating project skills ("never create one — a new project skill
  * silently shadows a same-named built-in skill") and makes exactly one exception — "The single exception is
  * verify, because how a project verifies changes is project-specific: put a verify correction in the
  * `.claude/skills/verify/ SKILL.md` closest to the code it covers … and if that file does not exist, create
@@ -338,8 +338,9 @@ export interface DeveloperTaskConfig extends VerifyConfig {
     verify?: boolean;
 }
 /**
- * One-stop developer-mode convenience: applies {@link CODE_AGENT_PROMPT} (unless the task supplies its
- * own `systemPrompt`) and, by default, runs the {@link runWithVerification} gate. Equivalent to wiring
+ * One-stop developer-mode convenience: gives the task the catalog's coding role base by word (`promptRole: "code"`, on
+ * the task's own seat, so no role preset overtakes it) unless the task names a role base of its own (`promptRole` or
+ * `systemPrompt`), and, by default, runs the {@link runWithVerification} gate. Equivalent to wiring
  * the building blocks by hand — use the building blocks directly when you want full control.
  *
  * Pair with a role map that gives a strong implementation model and cheaper helper/verifier models for

package/dist/agents/verify.js

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { CODE_AGENT_PROMPT } from "../prompts/default.js";
+import { namesRoleBase } from "../prompt-assembly/role-base.js";
 import { releaseSession } from "./session-util.js";
 import { childClampSeats, clampSourceOf, engineHeadlessLegSeats } from "../core/child-clamp-seats.js";
 import { mapNestedSuspend, isDurablePause, pauseFamily } from "./suspend-guard.js";
@@ -179,7 +179,7 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
                 ? { restoreGatedTools: Array.isArray(specBase.restoreGatedTools) ? [...specBase.restoreGatedTools] : specBase.restoreGatedTools }
                 : {}),
             ...(specBase.clientContext !== undefined ? { clientContext: { ...specBase.clientContext } } : {}),
-            ...(specBase.promptProfile !== undefined ? { promptProfile: specBase.promptProfile } : {}),
+            ...(specBase.promptLean !== undefined ? { promptLean: specBase.promptLean } : {}),
             signal: specBase.signal,
         };
         const v = await runner.runTask(verifierSpec, withLegIdentity(legInternals(), { kind: "verifier", round }));
@@ -297,7 +297,7 @@ export async function resumeWithVerification(runner, token, outcome, taskConfig,
     return verifyCompleted(runner, result, taskConfig, objective, config, internals);
 }
 export async function runDeveloperTask(runner, spec, config = {}, internals) {
-    const implSpec = { systemPrompt: CODE_AGENT_PROMPT, ...spec };
+    const implSpec = namesRoleBase(spec) ? spec : { ...spec, promptRole: "code" };
     if (config.verify === false) {
         const result = await runner.runTask(implSpec, withLegIdentity(internals, IMPL_LEG));
         return { ...result, verification: { verdict: "unverified", unverifiedReason: "opted_out", rounds: 0, findings: [] } };

package/dist/brain/anthropic.js

@@ -5,20 +5,15 @@ import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
 import { STREAM_TORN_WARNING, createRepetitionPoll, createStreamEndLedger, modelOutputInvalidOf, noteResponseModel, nameMissingCause, parseStreamedToolArgs, placeTurnNotes, truncationCauseClause } from "./stream-shared.js";
 import { admitToolCallId, providerResultIds, providerToolCallId, responseToolCallIds } from "./tool-call-id.js";
 import { emitBrainTelemetry, reportReasoningWireFacts } from "./status-sink.js";
-import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, modelSupportsVision, sendableImages } from "./media-degrade.js";
-import { ANTHROPIC_RESERVED, OUTPUT_CAP_KEYS, applyExtraBody, effectiveOutputCap, headerBagOnce, lockHeader, mergeHeaders, takeHeaderCasefold } from "./request-params.js";
+import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imageWithholdOf, reportImagesWithheld, sendableImages } from "./media-degrade.js";
+import { ANTHROPIC_RESERVED, OUTPUT_CAP_KEYS, applyExtraBody, effectiveOutputCap, headerBagOnce, lockHeader, mergeHeaders, takeHeaderSpellings } from "./request-params.js";
 import { admitRouteRequest, applyRouteCredentialHeaders, assertServableRequestRoot, brainConfigSnapshot, createBrainRouteJudge, joinRequestUrl, resolveRequestRootOf, resolveRouteCredential } from "./route-adjudicator.js";
 import { requestRouteOf } from "./request-route.js";
-import { MIN_THINKING_TOKENS, budgetCapSkipsThinking, declaredEffortLevels, reasoningBudgetShare, reasoningRequestCarried, resolveEffort } from "./reasoning.js";
+import { NAMES_AS_WRITTEN, resolveProviderDialect, endpointToolNames } from "./provider-dialect.js";
+import { applyReasoningToRequest, mergeReasoningHeaders } from "./reasoning-request.js";
 import { runStreamingBrain } from "./stream-engine.js";
 import { refuseRetiredTimeoutKnobs } from "./timeout.js";
 import { resolveFetch } from "./transport.js";
-function thinkingBudget(maxTokens, share, fixed, hardCap = false) {
-    const max = hardCap ? maxTokens : Math.max(maxTokens, MIN_THINKING_TOKENS * 2);
-    const want = fixed ?? Math.floor(max * share);
-    const budget = Math.min(Math.max(MIN_THINKING_TOKENS, want), max - 1);
-    return { max, budget };
-}
 const EPHEMERAL = { type: "ephemeral" };
 const DOCUMENT_OMITTED_NO_VISION = "[PDF document omitted: the serving model does not support document input; extract the text via Bash instead (e.g. `pdftotext`).]";
 function textOf(content) {
@@ -26,7 +21,7 @@ function textOf(content) {
         ? content
         : content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
 }
-function toUserBlocks(content, supportsVision = true) {
+function toUserBlocks(content, withhold) {
     if (typeof content === "string") {
         return content.length > 0 ? [{ type: "text", text: content }] : [];
     }
@@ -37,7 +32,7 @@ function toUserBlocks(content, supportsVision = true) {
             blocks.push({ type: "text", text: c.text });
         }
         else if (c.type === "image" && c.data && c.mimeType) {
-            if (supportsVision)
+            if (withhold === undefined)
                 blocks.push({ type: "image", source: { type: "base64", media_type: c.mimeType, data: c.data } });
             else {
                 omitted++;
@@ -45,12 +40,13 @@ function toUserBlocks(content, supportsVision = true) {
             }
         }
     }
-    if (omitted > 0)
-        emitBrainTelemetry({ kind: "vision_placeholder", count: omitted });
+    if (withhold !== undefined)
+        reportImagesWithheld(withhold, omitted);
     return blocks;
 }
-function toAnthropicMessages(ctx, model) {
-    const supportsVision = modelSupportsVision(model);
+function toAnthropicMessages(ctx, model, toolNames) {
+    const imageWithhold = imageWithholdOf(model);
+    const supportsVision = imageWithhold === undefined;
     const raw = [];
     let pendingDocs = [];
     const flushDocs = () => {
@@ -64,7 +60,7 @@ function toAnthropicMessages(ctx, model) {
         if (m.role !== "toolResult")
             flushDocs();
         if (m.role === "user") {
-            const ub = toUserBlocks(m.content, supportsVision);
+            const ub = toUserBlocks(m.content, imageWithhold);
             raw.push({ role: "user", content: ub.length ? ub : [{ type: "text", text: NO_CONTENT }] });
         }
         else if (m.role === "assistant") {
@@ -86,7 +82,7 @@ function toAnthropicMessages(ctx, model) {
                     blocks.push({ type: "text", text: c.text });
                 }
                 else if (c.type === "toolCall") {
-                    blocks.push({ type: "tool_use", id: providerToolCallId(c), name: c.name, input: c.arguments ?? {} });
+                    blocks.push({ type: "tool_use", id: providerToolCallId(c), name: toolNames.sent(c.name), input: c.arguments ?? {} });
                 }
             }
             raw.push({ role: "assistant", content: blocks.length ? blocks : [{ type: "text", text: NO_CONTENT }] });
@@ -96,7 +92,7 @@ function toAnthropicMessages(ctx, model) {
             const docs = parts ? parts.filter((c) => c.type === "document") : [];
             const rest = docs.length > 0 && parts ? parts.filter((c) => c.type !== "document") : m.content;
             const hasImage = !m.isError && Array.isArray(rest) && rest.some((c) => c.type === "image");
-            let inner = hasImage ? toUserBlocks(rest, supportsVision) : textOf(rest);
+            let inner = hasImage ? toUserBlocks(rest, imageWithhold) : textOf(rest);
             if (docs.length > 0 && !m.isError) {
                 if (supportsVision) {
                     for (const d of docs) {
@@ -155,12 +151,12 @@ function toAnthropicMessages(ctx, model) {
     }
     return merged;
 }
-function toAnthropicTools(ctx, cacheBreakpoints) {
+function toAnthropicTools(ctx, cacheBreakpoints, toolNames) {
     if (!ctx.tools || ctx.tools.length === 0) {
         return undefined;
     }
     return ctx.tools.map((t, i) => ({
-        name: t.name,
+        name: toolNames.sent(t.name),
         description: t.description,
         input_schema: t.parameters,
         ...(cacheBreakpoints && i === ctx.tools.length - 1 ? { cache_control: EPHEMERAL } : {}),
@@ -238,6 +234,7 @@ export function createAnthropicBrain(given = {}) {
         let thinkingRequested = false;
         let sentMaxTokens;
         let sentMaxTokensLane = "config-default";
+        let sentToolNames = NAMES_AS_WRITTEN;
         return runStreamingBrain({
             model,
             doFetch,
@@ -249,6 +246,8 @@ export function createAnthropicBrain(given = {}) {
             buildRequest: (overrides) => {
                 const routed = { id: model.id, baseUrl: model.baseUrl };
                 const { root, origin: rootOrigin } = resolveRequestRootOf(routed.baseUrl, config.baseUrl, ANTHROPIC_DEFAULT_BASE_URL);
+                const url = joinRequestUrl(root, "/v1/messages");
+                const builtToolNames = endpointToolNames(resolveProviderDialect(url, model.api), model.api, (context.tools ?? []).map((t) => t.name));
                 const modelHeaders = headerBagOnce(model.headers);
                 const optionsHeaders = headerBagOnce(options?.headers);
                 const routeCredential = resolveRouteCredential({
@@ -274,80 +273,42 @@ export function createAnthropicBrain(given = {}) {
                 const body = {
                     model: model.id,
                     max_tokens: overrides?.maxOutputTokens ?? options?.maxTokens ?? model.maxTokens ?? config.defaultMaxTokens ?? 4096,
-                    messages: toAnthropicMessages(context, model),
+                    messages: toAnthropicMessages(context, model, builtToolNames),
                     stream: true,
                 };
                 if (system)
                     body.system = system;
-                const tools = toAnthropicTools(context, cacheBreakpoints);
+                const tools = toAnthropicTools(context, cacheBreakpoints, builtToolNames);
                 if (tools)
                     body.tools = tools;
                 const anthCompat = (model.compat ?? {});
                 if (options?.temperature !== undefined && anthCompat.supportsTemperature !== false) {
                     body.temperature = options.temperature;
                 }
-                let builtReasoningFacts;
-                let thinkingOn = false;
-                if (reasoningRequestCarried(model, options?.reasoning)) {
-                    if (anthCompat.thinkingMode === "adaptive") {
-                        body.thinking = { type: "adaptive" };
-                        thinkingOn = true;
-                    }
-                    else {
-                        const hardCap = overrides?.maxOutputTokens !== undefined || options?.maxTokens !== undefined;
-                        builtReasoningFacts = { outputCapTokens: body.max_tokens, hardOutputCap: hardCap };
-                        if (budgetCapSkipsThinking(builtReasoningFacts.outputCapTokens, builtReasoningFacts.hardOutputCap)) {
-                            body.thinking = undefined;
-                            delete body.thinking;
-                        }
-                        else {
-                            const share = config.thinkingBudgetShare ?? reasoningBudgetShare(options.reasoning);
-                            const { max, budget } = thinkingBudget(body.max_tokens, share, config.thinkingBudgetTokens, hardCap);
-                            body.max_tokens = max;
-                            body.thinking = { type: "enabled", budget_tokens: budget };
-                            thinkingOn = true;
-                        }
-                    }
-                    if (thinkingOn)
-                        delete body.temperature;
-                }
-                else if (model.reasoning && options?.reasoning === "off" && anthCompat.thinkingMode !== "adaptive") {
-                    body.thinking = { type: "disabled" };
-                }
-                const betas = [];
-                let sendEffortBeta = false;
-                const declaredEffort = declaredEffortLevels(anthCompat.effortLevels);
-                if (declaredEffort !== undefined && reasoningRequestCarried(model, options?.reasoning)) {
-                    const { effective } = resolveEffort(options.reasoning, declaredEffort);
-                    const wireEffort = effective === "minimal" ? "low" : effective;
-                    body.output_config = { effort: wireEffort };
-                    sendEffortBeta = true;
-                }
-                if (sendEffortBeta)
-                    betas.push("effort-2025-11-24");
-                if (anthCompat.contextManagement && thinkingOn) {
-                    body.context_management = { edits: [{ type: "clear_thinking_20251015", keep: "all" }] };
-                    betas.push("context-management-2025-06-27");
-                }
-                if (anthCompat.interleavedThinking) {
-                    betas.push("interleaved-thinking-2025-05-14");
-                }
-                const headers = mergeHeaders(modelHeaders, config.headers, optionsHeaders);
+                const hardCap = overrides?.maxOutputTokens !== undefined || options?.maxTokens !== undefined;
+                const { body: reasoningBody, headers: reasoningHeaders, wireFacts: builtReasoningFacts, } = applyReasoningToRequest({
+                    api: "anthropic-messages",
+                    model,
+                    level: options?.reasoning,
+                    body,
+                    budget: { capIsHard: hardCap, share: config.thinkingBudgetShare, tokens: config.thinkingBudgetTokens },
+                });
+                const headerLayers = [modelHeaders, config.headers, optionsHeaders];
+                const headers = mergeHeaders(...headerLayers);
                 applyRouteCredentialHeaders(headers, routeCredential);
-                if (betas.length > 0) {
-                    const existing = (takeHeaderCasefold(headers, "anthropic-beta") ?? "").split(",").map((b) => b.trim()).filter(Boolean);
-                    for (const beta of betas) {
-                        if (!existing.includes(beta))
-                            existing.push(beta);
-                    }
-                    headers["anthropic-beta"] = existing.join(",");
+                takeHeaderSpellings(headers, "anthropic-beta");
+                for (const layer of headerLayers) {
+                    for (const [name, value] of Object.entries(layer ?? {}))
+                        if (name.toLowerCase() === "anthropic-beta")
+                            mergeReasoningHeaders(headers, { [name]: value });
                 }
+                mergeReasoningHeaders(headers, reasoningHeaders);
                 lockHeader(headers, "content-type", "application/json");
                 lockHeader(headers, "anthropic-version", config.version ?? "2023-06-01");
                 if (apiKey)
                     lockHeader(headers, ANTHROPIC_KEY_HEADER, apiKey);
-                const builtThinkingRequested = body.thinking !== undefined;
-                const builtMaxTokens = body.max_tokens;
+                const builtThinkingRequested = reasoningBody.thinking !== undefined;
+                const builtMaxTokens = reasoningBody.max_tokens;
                 const builtMaxTokensLane = overrides?.maxOutputTokens !== undefined
                     ? "engine"
                     : options?.maxTokens !== undefined
@@ -355,9 +316,9 @@ export function createAnthropicBrain(given = {}) {
                         : model.maxTokens !== undefined
                             ? "model"
                             : "config-default";
-                const { body: wire, dropped: extraBodyDropped } = applyExtraBody(body, model.extraBody, ANTHROPIC_RESERVED);
+                const { body: wire, dropped: extraBodyDropped } = applyExtraBody(reasoningBody, model, ANTHROPIC_RESERVED);
                 return {
-                    url: joinRequestUrl(root, "/v1/messages"),
+                    url,
                     headers,
                     body: JSON.stringify(wire),
                     extraBodyDropped,
@@ -369,6 +330,7 @@ export function createAnthropicBrain(given = {}) {
                         thinkingRequested = builtThinkingRequested;
                         sentMaxTokens = builtMaxTokens;
                         sentMaxTokensLane = builtMaxTokensLane;
+                        sentToolNames = builtToolNames;
                         if (builtReasoningFacts !== undefined)
                             reportReasoningWireFacts(builtReasoningFacts);
                     },
@@ -540,7 +502,7 @@ export function createAnthropicBrain(given = {}) {
                             else if (cb.type === "tool_use") {
                                 acc.type = "tool_use";
                                 acc.toolId = cb.id ?? "";
-                                acc.toolName = cb.name ?? "";
+                                acc.toolName = sentToolNames.called(cb.name ?? "");
                             }
                             else {
                                 acc.type = "text";

package/dist/brain/errors.d.ts

@@ -256,6 +256,21 @@ export declare function abortLikeName(err: unknown): "AbortError" | "TimeoutErro
  *  rather than testing `instanceof BrainError`, which walks a chain a revoked proxy traps — and the one
  *  site that did so sits in an async IIFE with no `.catch`. */
 export declare function brainErrorCodeOf(e: unknown): BrainErrorCode | undefined;
+/** What a thrown brain failure says about itself in machine words: its code, and the structural input-too-long cause
+ *  its minter declared (or ruled out). Empty for a value that carries no brain code. */
+export interface ThrownBrainFailure {
+    readonly code?: BrainErrorCode;
+    readonly errorKind?: "input_too_long";
+    readonly inputTooLongRuledOut?: true;
+}
+/**
+ * The one reading of a thrown brain failure's structure: the code word ({@link brainErrorCodeOf}, never `instanceof`)
+ * and, only when the value carries a code, the input-too-long cause it was minted with — read by brand, so a value from
+ * another realm or behind a revoked proxy reads the same as a local `BrainError`. The stream engine's terminal shell and
+ * every caller that catches a brain call read it, so a failure that is thrown and one that is returned on a message
+ * carry the same facts.
+ */
+export declare function thrownBrainFailure(e: unknown): ThrownBrainFailure;
 /** Render a transport-level error WITHOUT folding away its cause chain: undici rejects with
  *  `TypeError("fetch failed", { cause })` where the CAUSE carries the actionable fact, and the shell
  *  alone reads the same for refused / DNS / mid-stream disconnect. Walks the chain (bounded), appending

package/dist/brain/errors.js

@@ -247,6 +247,16 @@ export function brainErrorCodeOf(e) {
     const code = readMember(e, "code");
     return typeof code === "string" && BRAIN_ERROR_CODES.includes(code) ? code : undefined;
 }
+export function thrownBrainFailure(e) {
+    const code = brainErrorCodeOf(e);
+    if (code === undefined)
+        return {};
+    if (readMember(e, "inputTooLong") === true)
+        return { code, errorKind: "input_too_long" };
+    if (readMember(e, "inputTooLongRuledOut") === true)
+        return { code, inputTooLongRuledOut: true };
+    return { code };
+}
 export function describeNetworkError(e) {
     const top = thrownText(e);
     const parts = [];

package/dist/brain/media-degrade.d.ts

@@ -7,15 +7,26 @@
  * sentence that drifts is a string consumers grep for.
  */
 import type { Model } from "../internal/llm.js";
+import { type CapabilityDeclaration } from "./model-capability.js";
+/** Why a request's images are withheld from the SERVING model: the entry's image declaration, when it is not held
+ *  (the withheld-capability report's `cause`, `status-sink.ts`). */
+export type ImageWithholdCause = Exclude<CapabilityDeclaration, "declared_on">;
+/** A request whose images are withheld: which model, and why. */
+export interface ImageWithhold {
+    readonly modelId: string;
+    readonly cause: ImageWithholdCause;
+}
 /**
- * Whether the SERVING model accepts image input (`Model.input` contains "image").
- *
- * An ABSENT `input` is deliberately permissive (vision on): the field is caller-supplied metadata,
- * and treating "not declared" as "not capable" would silently downgrade every caller who never
- * filled it in. A caller that genuinely serves a text-only endpoint declares `input: ["text"]` and
- * gets the placeholder path — the case a text-only API rejects with a hard 400 on an image part.
+ * The image row of the capability table for one request: `undefined` = images ride as images; otherwise the model and
+ * the declaration that withholds them. Read off the one capability reading (`capabilityHeld` / `capabilityOf`), so an
+ * entry that never declared `input` gets its images exactly as the table says, and an entry that declares a list without
+ * `"image"` gets the placeholder path — the case a text-only API rejects with a hard 400 on an image part. No model =
+ * images ride.
  */
-export declare function modelSupportsVision(model?: Model): boolean;
+export declare function imageWithholdOf(model?: Model): ImageWithhold | undefined;
+/** Report `count` images of one request replaced by placeholders — the one emit for every lane: the operator trace frame
+ *  (telemetry, per request) and the leg's withheld-capability account (the person's notice, once per conversation). */
+export declare function reportImagesWithheld(withhold: ImageWithhold, count: number): void;
 /** Placeholder for an image block dropped because the serving model declares no image input. */
 export declare const IMAGE_OMITTED_NO_VISION = "[image omitted: the serving model does not support image input]";
 /** {@link IMAGE_OMITTED_NO_VISION}, counted — a batch of dropped images states how many were lost. */

package/dist/brain/media-degrade.js

@@ -1,5 +1,16 @@
-export function modelSupportsVision(model) {
-    return model?.input === undefined ? true : model.input.includes("image");
+import { capabilityHeld, capabilityOf } from "./model-capability.js";
+import { emitBrainTelemetry, reportCapabilityWithheld } from "./status-sink.js";
+export function imageWithholdOf(model) {
+    if (model === undefined)
+        return undefined;
+    const declared = capabilityOf(model, "image");
+    return declared === "declared_on" || capabilityHeld(model, "image") ? undefined : { modelId: model.id, cause: declared };
+}
+export function reportImagesWithheld(withhold, count) {
+    if (count === 0)
+        return;
+    emitBrainTelemetry({ kind: "vision_placeholder", count });
+    reportCapabilityWithheld({ modelId: withhold.modelId, capability: "image", cause: withhold.cause, count });
 }
 export const IMAGE_OMITTED_NO_VISION = "[image omitted: the serving model does not support image input]";
 export function imagesOmittedNoVisionNote(count) {

package/dist/brain/model-capability.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The ONE reading of a model's capability declarations — image input and reasoning.
+ *
+ * A `Model` declares each capability in one of three states: on (`reasoning: true`; `input` lists `"image"`), off
+ * (`reasoning: false`; an `input` list without `"image"`), or not at all (the key is absent). Every reader in the engine
+ * (bar the PDF profile's no-metadata shortcut in `pdfModelCapabilitiesOf`, which looks at the absence itself) asks {@link capabilityOf} for the declaration, or {@link capabilityHeld} for "does the engine treat this model as
+ * having it", and what an undeclared capability means is stated once, in {@link UNKNOWN_CAPABILITY_READS} — no caller
+ * decides it for itself. A request never carries a capability declared off; one declared on is never dropped here.
+ *
+ * A declaration of the wrong shape is refused where it is read: a `reasoning` that is not a boolean, or an `input` that
+ * is not a list of strings, throws, naming the model and the key. Reading it some other way (by truthiness, or as
+ * undeclared) would turn a typo into a capability nobody declared.
+ */
+import type { Model } from "../internal/llm.js";
+/** The capabilities a model declares. `image` = accepts image input (`Model.input` lists `"image"`). */
+export declare const MODEL_CAPABILITIES: readonly ["image", "reasoning"];
+export type ModelCapability = (typeof MODEL_CAPABILITIES)[number];
+/** What a model's entry says about one capability. `unknown` = the entry does not say. */
+export declare const CAPABILITY_DECLARATIONS: readonly ["declared_on", "declared_off", "unknown"];
+export type CapabilityDeclaration = (typeof CAPABILITY_DECLARATIONS)[number];
+/**
+ * What the engine does with a capability the entry does not declare, per capability — the only place this is said.
+ * Image input is used (an entry that never filled in `input` keeps the images it was always sent). Reasoning is not:
+ * no thinking keys go out for an entry that does not declare `reasoning` (the request is the provider's default).
+ */
+export declare const UNKNOWN_CAPABILITY_READS: Readonly<Record<ModelCapability, "held" | "not_held">>;
+/** The part of a model this module reads (`id` only names the model in a refusal; the structural readers that take a
+ *  model-shaped object without one still get the same answer). */
+export type CapabilityDeclaringModel = {
+    readonly id?: Model["id"];
+    readonly reasoning?: unknown;
+    readonly input?: unknown;
+};
+/** The entry's declaration of `cap`. Throws a `TypeError` on a declaration of the wrong shape (see the module note). */
+export declare function capabilityOf(model: CapabilityDeclaringModel, cap: ModelCapability): CapabilityDeclaration;
+/** Whether the engine treats the model as having `cap`: declared on, or undeclared where {@link UNKNOWN_CAPABILITY_READS} says held. */
+export declare function capabilityHeld(model: CapabilityDeclaringModel, cap: ModelCapability): boolean;

package/dist/brain/model-capability.js

@@ -0,0 +1,34 @@
+export const MODEL_CAPABILITIES = Object.freeze(["image", "reasoning"]);
+export const CAPABILITY_DECLARATIONS = Object.freeze(["declared_on", "declared_off", "unknown"]);
+export const UNKNOWN_CAPABILITY_READS = Object.freeze({
+    image: "held",
+    reasoning: "not_held",
+});
+function typeWordOf(value) {
+    return value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+}
+function nameOf(model) {
+    return typeof model.id === "string" ? `"${model.id}"` : "a model with no id";
+}
+export function capabilityOf(model, cap) {
+    if (cap === "reasoning") {
+        const declared = model.reasoning;
+        if (declared === undefined)
+            return "unknown";
+        if (typeof declared !== "boolean") {
+            throw new TypeError(`Model.reasoning of ${nameOf(model)} must be true, false or absent; got ${typeWordOf(declared)}`);
+        }
+        return declared ? "declared_on" : "declared_off";
+    }
+    const input = model.input;
+    if (input === undefined)
+        return "unknown";
+    if (!Array.isArray(input) || !input.every((m) => typeof m === "string")) {
+        throw new TypeError(`Model.input of ${nameOf(model)} must be a list of input kinds or absent; got ${Array.isArray(input) ? "a list holding a non-string" : typeWordOf(input)}`);
+    }
+    return input.includes("image") ? "declared_on" : "declared_off";
+}
+export function capabilityHeld(model, cap) {
+    const declared = capabilityOf(model, cap);
+    return declared === "declared_on" || (declared === "unknown" && UNKNOWN_CAPABILITY_READS[cap] === "held");
+}

package/dist/brain/model-presets.d.ts

@@ -1,5 +1,5 @@
 /**
- * First-party model presets (design/119, CC 2.1.198 rebaseline).
+ * First-party model presets (design/119).
  *
  * sema stays caller-injects-`Model` by design (no baked catalog — the CC catalog/alias/family layer
  * is a product surface we deliberately don't carry). What IS worth shipping is the per-model
@@ -7,12 +7,12 @@
  * (adaptive thinking form, effort tiers, temperature rejection) that a wrong guess turns into a
  * hard 400. These presets are DATA, not mechanism — every field can be overridden by the caller.
  *
- * Pricing is deliberately NOT baked (CC 198 doesn't bake it either): `cost` defaults to zeros and a
+ * Pricing is deliberately NOT baked (the reference doesn't bake it either): `cost` defaults to zeros and a
  * deployment that wants cost accounting fills in the current official per-MTok rates.
  */
 import type { AnthropicMessagesCompat, Model } from "../internal/llm.js";
 /**
- * The Fable-5-class Anthropic wire contract (CC 2.1.198 capability bits, design/119 P0):
+ * The Fable-5-class Anthropic wire contract (capability bits, design/119 P0):
  * - `thinkingMode: "adaptive"` — `thinking: { type: "adaptive" }`, NO budget_tokens (400 on budget).
  * - `effortLevels` — the full five-tier `output_config.effort` range (fable-5 has `xhigh_effort` +
  *   `max_effort`; a model without those bits should declare a shorter list and higher requests clamp).
@@ -20,15 +20,9 @@ import type { AnthropicMessagesCompat, Model } from "../internal/llm.js";
  */
 export declare const FABLE_5_COMPAT: AnthropicMessagesCompat;
 /**
- * The fable lines the classic prompt shape serves. They are prompt text, so they live with the prompt
- * text; this name stays exported for hosts that read them. The preset below no longer carries them as
- * `promptGuidance`: the prompt composes them itself, once, where they are the only fable text.
- */
-export declare const FABLE_5_PROMPT_GUIDANCE: readonly string[];
-/**
- * A ready-to-use `claude-fable-5` {@link Model} (CC 2.1.198 registry facts: 1M-token native context
+ * A ready-to-use `claude-fable-5` {@link Model} (registry facts: 1M-token native context
  * window, 64k default max output — the 128k tier is opt-in via `maxTokens` override, knowledge
- * cutoff Jan 2026, `default_effort: "high"`). Override anything per deployment; set `cost` for
- * accounting (not baked — see module note).
+ * cutoff Jan 2026, `default_effort: "high"`, prompt capabilities `lean_prompt` + `fable_5_mitigations`).
+ * Override anything per deployment; set `cost` for accounting (not baked — see module note).
  */
 export declare function fable5Model(overrides?: Partial<Model>): Model;

package/dist/brain/model-presets.js

@@ -1,15 +1,9 @@
-import { catalogText } from "../prompt-assembly/catalog/index.js";
 import { ANTHROPIC_DEFAULT_BASE_URL } from "./anthropic.js";
 export const FABLE_5_COMPAT = {
     thinkingMode: "adaptive",
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
     supportsTemperature: false,
 };
-export const FABLE_5_PROMPT_GUIDANCE = [
-    catalogText("core/behavior.fable-classic.final-message"),
-    catalogText("core/behavior.fable-classic.autonomy"),
-    catalogText("core/behavior.fable-classic.tool-json"),
-];
 export function fable5Model(overrides = {}) {
     return {
         id: "claude-fable-5",
@@ -25,6 +19,7 @@ export function fable5Model(overrides = {}) {
         maxTokens: 64_000,
         charsPerToken: 3,
         compat: { ...FABLE_5_COMPAT },
+        promptTraits: ["lean_prompt", "fable_5_mitigations"],
         ...overrides,
     };
 }