@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/mcpPanel.d.ts

@@ -1,6 +1,7 @@
 import type { AgentClient } from '@sema-agent/sdk';
 import { type WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
 import { type McpEngineLegHealth } from './mcpLiveness.js';
+import { type ScenarioRefusalReading } from './scenarioRefusal.js';
 export interface McpPanelServerView {
     name: string;
     status: string;
@@ -16,14 +17,22 @@ export interface McpPanelLastLegView {
     at: string;
     mcp: WiringManifestMcpEntryView[];
 }
-export interface McpPanelView {
+export interface McpPanelServersView {
     asOf: string;
+    lastLegMcp?: McpPanelLastLegView;
+    lastLegMcpUnreadable?: true;
     servers: McpPanelServerView[];
     degraded?: true;
+}
+export interface McpPanelRefusalView {
+    asOf: string;
     lastLegMcp?: McpPanelLastLegView;
     lastLegMcpUnreadable?: true;
+    scenarioRefusal: ScenarioRefusalReading;
 }
+export type McpPanelView = McpPanelServersView | McpPanelRefusalView;
 export declare function projectMcpPanel(body: unknown): McpPanelView | undefined;
+export declare function mcpPanelRefusalOf(view: McpPanelView | undefined): ScenarioRefusalReading | undefined;
 export declare function fetchMcpPanel(client: Pick<AgentClient, 'sessions'>, sessionId: string, opts?: {
     signal?: AbortSignal;
 }): Promise<McpPanelView | undefined>;

package/dist/mcpPanel.js

@@ -3,6 +3,7 @@ import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { mcpLivenessRollupOf } from './mcpLiveness.js';
+import { scenarioRefusalOf } from './scenarioRefusal.js';
 const MCP_PANEL_ERROR_MAX = 200;
 const MCP_PANEL_WORD_MAX = 40;
 const MCP_PANEL_NAMES_MAX = 8;
@@ -40,19 +41,29 @@ export function projectMcpPanel(body) {
         return undefined;
     if (!nonEmpty(body.asOf))
         return undefined;
-    if (!Array.isArray(body.servers))
+    const refusal = scenarioRefusalOf(body);
+    if (refusal === null)
         return undefined;
-    const servers = [];
-    for (const r of body.servers) {
-        const row = projectServerRow(r);
-        if (row !== undefined)
-            servers.push(row);
+    let view;
+    if (refusal !== undefined) {
+        view = { asOf: body.asOf, scenarioRefusal: refusal };
+    }
+    else {
+        if (!Array.isArray(body.servers))
+            return undefined;
+        const servers = [];
+        for (const r of body.servers) {
+            const row = projectServerRow(r);
+            if (row !== undefined)
+                servers.push(row);
+        }
+        if (body.servers.length > 0 && servers.length === 0)
+            return undefined;
+        const sv = { asOf: body.asOf, servers };
+        if (body.degraded === true)
+            sv.degraded = true;
+        view = sv;
     }
-    if (body.servers.length > 0 && servers.length === 0)
-        return undefined;
-    const view = { asOf: body.asOf, servers };
-    if (body.degraded === true)
-        view.degraded = true;
     if ('lastLegMcp' in body) {
         const leg = projectLastLeg(body.lastLegMcp);
         if (leg !== undefined)
@@ -62,6 +73,20 @@ export function projectMcpPanel(body) {
     }
     return view;
 }
+export function mcpPanelRefusalOf(view) {
+    try {
+        if (view === null || typeof view !== 'object')
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(view, 'scenarioRefusal');
+        if (d === undefined || !('value' in d))
+            return undefined;
+        const r = d.value;
+        return r !== null && typeof r === 'object' && !Array.isArray(r) ? r : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function fetchMcpPanel(client, sessionId, opts) {
     if (!isSessionIdPathSegment(sessionId))
         return undefined;
@@ -98,12 +123,14 @@ void _mcpPanelShapePin;
 export function mcpEngineLegPresence(view) {
     if (view === undefined)
         return 'unknown';
-    if (view.servers.length > 0)
-        return 'present';
     if (view.lastLegMcp !== undefined)
         return 'present';
     if (view.lastLegMcpUnreadable === true)
         return 'present';
+    if (!('servers' in view))
+        return 'unknown';
+    if (view.servers.length > 0)
+        return 'present';
     if (view.degraded === true)
         return 'present';
     return 'absent';

package/dist/mcpProbeCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type McpProbeReading = {
     kind: 'unobserved';
 } | {
@@ -12,4 +13,4 @@ export type McpProbeReading = {
 export declare function projectMcpProbeCapability(caps: unknown): McpProbeReading | undefined;
 export declare function observedMcpProbe(baseUrl?: string | undefined): McpProbeReading;
 export declare function mcpProbeAvailable(reading: McpProbeReading): 'yes' | 'no' | 'unknown';
-export declare function mcpProbeDoctorDetail(reading: McpProbeReading): string;
+export declare function mcpProbeDoctorDetail(reading: McpProbeReading, lang?: UiLanguage): string;

package/dist/mcpProbeCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectMcpProbeCapability(caps) {
     try {
@@ -30,22 +31,17 @@ export function mcpProbeAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function mcpProbeDoctorDetail(reading) {
+export function mcpProbeDoctorDetail(reading, lang) {
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('per-server MCP status face');
+            return unreadableReadingDetail(renderMessage(msg('notice.capability.subject.mcpProbe'), lang), lang);
         case 'unobserved':
-            return ('per-server MCP status face not observed — the engine reports whether it has one on /v1/capabilities; ' +
-                'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
+            return renderMessage(msg('notice.capability.mcpProbe.unobserved'), lang);
         case 'not_reported':
-            return ('per-server MCP status face not reported by this engine — this binary predates the face, so that path is not expected to exist here ' +
-                '(asking it usually answers with a machine-readable route-not-found, though a timeout or an uncoded gateway answer still says nothing either way); ' +
-                'prefer the session panel last-leg roster where that panel carries one, and otherwise show this reason rather than an entry that cannot answer');
+            return renderMessage(msg('notice.capability.mcpProbe.notReported'), lang);
         case 'absent':
-            return ('per-server MCP status face reported off on this deployment — this engine answers no readings there; ' +
-                'this client does not guess why, and whether caller-supplied declarations are honored is a separate position with its own answer');
+            return renderMessage(msg('notice.capability.mcpProbe.absent'), lang);
         case 'present':
-            return ('per-server MCP status face on — this engine dials its own declared MCP servers on request, with no run, ' +
-                'and a probe of caller-supplied declarations answers with the very same body shape');
+            return renderMessage(msg('notice.capability.mcpProbe.present'), lang);
     }
 }

package/dist/mcpProbeWire.d.ts

@@ -1,6 +1,7 @@
 import type { McpProbeFace, McpServerSpec } from '@sema-agent/sdk';
 import { type WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
 import { type McpProbeReading } from './mcpProbeCapability.js';
+import { type ScenarioRefusalReading } from './scenarioRefusal.js';
 export interface McpProbeFacade {
     mcpCapabilities(opts?: {
         signal?: AbortSignal;
@@ -9,7 +10,7 @@ export interface McpProbeFacade {
         signal?: AbortSignal;
     }): Promise<McpProbeFace>;
 }
-export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified"];
+export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified", "scenario_refused"];
 export type McpProbeRefusalCause = (typeof MCP_PROBE_REFUSAL_CAUSES)[number];
 export declare const MCP_PROBE_UNKNOWN_WHYS: readonly ["no_verdict", "probe_incomplete", "server_fault", "result_unreadable", "index_misaligned", "unclassified"];
 export type McpProbeUnknownWhy = (typeof MCP_PROBE_UNKNOWN_WHYS)[number];
@@ -18,6 +19,7 @@ export type McpProbeRefused = {
     cause: McpProbeRefusalCause;
     message: string;
     retryAfterSec?: number;
+    scenarioRefusal?: ScenarioRefusalReading;
 };
 export type McpProbeUnknown = {
     status: 'unknown';
@@ -35,13 +37,18 @@ export type McpProbeOutcome = {
     status: 'face';
     face: McpProbeFaceView;
 } | McpProbeRefused | McpProbeUnknown;
+export type McpDeploymentOutcome = {
+    status: 'face';
+    face: McpProbeFaceView;
+    declaredBy: 'deployment';
+} | McpProbeRefused | McpProbeUnknown;
 export declare function classifyMcpProbeFailure(e: unknown): McpProbeFailure;
 export interface McpCapabilitiesCall {
     capability: McpProbeReading;
 }
 export declare function readMcpCapabilities(facade: McpProbeFacade, call: McpCapabilitiesCall, opts?: {
     signal?: AbortSignal;
-}): Promise<McpProbeOutcome>;
+}): Promise<McpDeploymentOutcome>;
 export interface McpProbeServersCall {
     specs: McpServerSpec[];
     capability: McpProbeReading;

package/dist/mcpProbeWire.js

@@ -1,6 +1,7 @@
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { wireFailureShapeOf } from './wireFailureShape.js';
 import { mcpProbeAvailable } from './mcpProbeCapability.js';
+import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
     'face_absent',
     'client_too_old',
@@ -14,6 +15,7 @@ export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
     'unauthorized',
     'principal_required',
     'principal_unverified',
+    'scenario_refused',
 ]);
 export const MCP_PROBE_UNKNOWN_WHYS = Object.freeze([
     'no_verdict',
@@ -168,6 +170,9 @@ export async function readMcpCapabilities(facade, call, opts) {
         res = await facade.mcpCapabilities(opts);
     }
     catch (e) {
+        const refusal = scenarioRefusalFromError(e);
+        if (refusal !== null)
+            return { ...refusedBy('scenario_refused', wireFailureShapeOf(e).message), scenarioRefusal: refusal };
         return classifyMcpProbeFailure(e);
     }
     const narrowed = narrowProbeFace(res);
@@ -175,7 +180,7 @@ export async function readMcpCapabilities(facade, call, opts) {
         return unknownBy(narrowed.why, `the per-server MCP status call answered 2xx with a body this client cannot stand behind (${narrowed.what}) — refusing to present it as a reading, ` +
             'because a normal-looking empty list is exactly the false answer this face exists to remove');
     }
-    return { status: 'face', face: narrowed.face };
+    return { status: 'face', face: narrowed.face, declaredBy: 'deployment' };
 }
 export async function probeMcpServers(facade, call, opts) {
     if (typeof facade?.probeMcp !== 'function') {

package/dist/mcpWireCaps.d.ts

@@ -1,5 +1,6 @@
-import type { TaskRequest } from '@sema-agent/sdk';
-export type McpServerSpec = NonNullable<TaskRequest['mcpServers']>[number];
+import type { McpServerSpec } from '@sema-agent/sdk';
+import type { UiLanguage } from './env/uiLanguage.js';
+export type { McpServerSpec };
 export declare const MCP_CAPS: {
     readonly items: 32;
 };
@@ -10,9 +11,53 @@ export interface McpConfigLike {
     env?: Record<string, string>;
     url?: string;
     headers?: Record<string, string>;
+    principalHeader?: string;
+    assertionHeader?: string;
     allowTools?: string[];
+    elicitation?: {} | null | undefined;
     toolFaces?: unknown;
     toolAxes?: unknown;
 }
+export type McpHttpIdentityHeaders = {
+    readonly kind: 'ok';
+    readonly principalHeader?: string;
+    readonly assertionHeader?: string;
+} | {
+    readonly kind: 'both_set';
+};
+export declare function readMcpHttpIdentityHeaders(transport: object): McpHttpIdentityHeaders;
 export declare function mcpConfigToSpec(name: string, c: McpConfigLike): McpServerSpec | null;
 export declare function mcpConfigsToSpecs(servers: Record<string, McpConfigLike> | undefined): McpServerSpec[];
+export type McpToolAxesVerdict = {
+    readonly kind: 'ok';
+    readonly toolAxes?: Readonly<Record<string, object>>;
+} | {
+    readonly kind: 'bad';
+    readonly problem: string;
+} | {
+    readonly kind: 'unavailable';
+};
+export declare function mcpToolAxesVerdict(declared: {} | null | undefined): McpToolAxesVerdict;
+export declare function mcpElicitationVerdict(declared: {} | null | undefined): {
+    readonly kind: 'ok';
+    readonly elicitation?: boolean;
+} | {
+    readonly kind: 'bad';
+};
+export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'tool_axes_invalid' | 'elicitation_invalid';
+export interface McpConfigDropped {
+    readonly name: string;
+    readonly reason: McpConfigDropReason;
+    readonly problem?: string;
+    readonly notice: string;
+}
+export interface McpConfigProjection {
+    readonly specs: McpServerSpec[];
+    readonly dropped: readonly McpConfigDropped[];
+}
+export interface ProjectMcpConfigsOptions {
+    readonly sourceLabel?: (serverName: string) => string | undefined;
+    readonly lang?: UiLanguage;
+}
+export declare function projectMcpConfigs(servers: Record<string, McpConfigLike> | undefined, opts?: ProjectMcpConfigsOptions): McpConfigProjection;
+export declare function mcpAssertionHeaderNotSentNotice(specs: readonly McpServerSpec[]): string | undefined;

package/dist/mcpWireCaps.js

@@ -1,14 +1,51 @@
+import { guardedRead } from './ownKey.js';
+import { readMcpToolAxes } from './coreValuePorts.js';
+import { capForDisplay } from './fleetTaskDesc.js';
+import { msg, renderMessage } from './i18n/translate.js';
+const _mcpServerSpecPin = true;
+void _mcpServerSpecPin;
 export const MCP_CAPS = { items: 32 };
-function transparentKeys(c) {
+function transparentKeys(c, axes, elicitation) {
     return {
         ...(c.toolFaces !== undefined ? { toolFaces: c.toolFaces } : {}),
-        ...(c.toolAxes !== undefined ? { toolAxes: c.toolAxes } : {}),
+        ...(axes !== undefined ? { toolAxes: axes } : {}),
+        ...(elicitation !== undefined ? { elicitation } : {}),
+    };
+}
+function presentHeaderName(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function readMcpHttpIdentityHeaders(transport) {
+    const t = transport;
+    const principalHeader = presentHeaderName(t.principalHeader);
+    const assertionHeader = presentHeaderName(t.assertionHeader);
+    if (principalHeader !== undefined && assertionHeader !== undefined)
+        return { kind: 'both_set' };
+    return {
+        kind: 'ok',
+        ...(principalHeader !== undefined ? { principalHeader } : {}),
+        ...(assertionHeader !== undefined ? { assertionHeader } : {}),
     };
 }
 export function mcpConfigToSpec(name, c) {
-    const n = (name ?? '').trim();
-    if (!n)
-        return null;
+    return mcpConfigEntry(name, c).spec;
+}
+function mcpConfigEntry(name, c) {
+    if (mcpNameFlaw(name) !== undefined)
+        return { spec: null };
+    const declared = c.toolAxes;
+    const verdict = mcpToolAxesVerdict(declared);
+    const elDeclared = c.elicitation;
+    const elVerdict = mcpElicitationVerdict(elDeclared);
+    if (verdict.kind === 'bad' || elVerdict.kind === 'bad') {
+        const rest = specOf(name, c, undefined, undefined);
+        if (rest === null)
+            return { spec: null };
+        return verdict.kind === 'bad' ? { spec: null, axesProblem: verdict.problem } : { spec: null, elicitationInvalid: true };
+    }
+    return { spec: specOf(name, c, verdict.kind === 'ok' ? verdict.toolAxes : declared, elVerdict.elicitation) };
+}
+function specOf(n, c, axes, elicitation) {
     const kind = c.type ?? 'stdio';
     if (kind === 'stdio') {
         if (!c.command)
@@ -21,34 +58,145 @@ export function mcpConfigToSpec(name, c) {
                 ...(c.args && c.args.length > 0 ? { args: c.args } : {}),
                 ...(c.env ? { env: c.env } : {}),
             },
-            ...(c.allowTools && c.allowTools.length > 0 ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c),
+            ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
+            ...transparentKeys(c, axes, elicitation),
         };
     }
     if (kind === 'http') {
         if (!c.url)
             return null;
+        const id = readMcpHttpIdentityHeaders(c);
+        if (id.kind === 'both_set')
+            return null;
         return {
             name: n,
             transport: {
                 kind: 'http',
                 url: c.url,
                 ...(c.headers ? { headers: c.headers } : {}),
+                ...(id.principalHeader !== undefined ? { principalHeader: id.principalHeader } : {}),
+                ...(id.assertionHeader !== undefined ? { assertionHeader: id.assertionHeader } : {}),
             },
-            ...(c.allowTools && c.allowTools.length > 0 ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c),
+            ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
+            ...transparentKeys(c, axes, elicitation),
         };
     }
     return null;
 }
 export function mcpConfigsToSpecs(servers) {
-    const out = [];
-    for (const [name, c] of Object.entries(servers ?? {})) {
-        if (out.length >= MCP_CAPS.items)
+    return projectMcpConfigs(servers).specs;
+}
+export function mcpToolAxesVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    const read = readMcpToolAxes(declared);
+    if (read === undefined || read === null || typeof read !== 'object')
+        return Object.freeze({ kind: 'unavailable' });
+    if (read.ok === true) {
+        const copy = read.toolAxes;
+        return Object.freeze(typeof copy === 'object' && copy !== null ? { kind: 'ok', toolAxes: copy } : { kind: 'ok' });
+    }
+    if (read.ok === false) {
+        const problem = read.problem;
+        return Object.freeze({ kind: 'bad', problem: typeof problem === 'string' && problem.length > 0 ? problem : renderMessage(msg('config.mcp.toolAxesFallbackProblem')) });
+    }
+    return Object.freeze({ kind: 'unavailable' });
+}
+export function mcpElicitationVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    return typeof declared === 'boolean' ? Object.freeze({ kind: 'ok', elicitation: declared }) : Object.freeze({ kind: 'bad' });
+}
+function mcpNameFlaw(name) {
+    if (typeof name !== 'string')
+        return 'name_blank';
+    const t = name.trim();
+    if (t.length === 0)
+        return 'name_blank';
+    return t === name ? undefined : 'name_edge_whitespace';
+}
+const DROP_NAME_SHOWN = 80;
+const DROP_LABEL_SHOWN = 140;
+const DROP_PROBLEM_SHOWN = 300;
+function dropNotice(name, reason, problem, opts) {
+    let label;
+    try {
+        label = opts?.sourceLabel?.(name);
+    }
+    catch {
+        label = undefined;
+    }
+    const where = typeof label === 'string' && label.length > 0 ? ` (${capForDisplay(label, DROP_LABEL_SHOWN)})` : '';
+    const quoted = `"${capForDisplay(name, DROP_NAME_SHOWN)}"`;
+    const ref = reason === 'tool_axes_invalid'
+        ? msg('config.mcp.toolAxesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolAxesFallbackProblem')), DROP_PROBLEM_SHOWN) })
+        : reason === 'elicitation_invalid'
+            ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
+            : reason === 'name_blank'
+                ? msg('config.mcp.nameBlank', { name: quoted, where })
+                : reason === 'name_collides_after_trim'
+                    ? msg('config.mcp.nameCollides', { name: quoted, where })
+                    : msg('config.mcp.nameEdgeWhitespace', { name: quoted, where });
+    return renderMessage(ref, opts?.lang);
+}
+export function projectMcpConfigs(servers, opts) {
+    const specs = [];
+    const dropped = [];
+    const entries = Object.entries(servers ?? {});
+    const exactNames = new Set();
+    const trimmedCount = new Map();
+    for (const [name] of entries) {
+        const flaw = mcpNameFlaw(name);
+        if (flaw === undefined)
+            exactNames.add(name);
+        else if (flaw === 'name_edge_whitespace')
+            trimmedCount.set(name.trim(), (trimmedCount.get(name.trim()) ?? 0) + 1);
+    }
+    for (const [name, c] of entries) {
+        if (specs.length >= MCP_CAPS.items)
             break;
-        const spec = mcpConfigToSpec(name, c);
-        if (spec)
-            out.push(spec);
+        const flaw = mcpNameFlaw(name);
+        if (flaw !== undefined) {
+            const reason = flaw === 'name_edge_whitespace' && (exactNames.has(name.trim()) || (trimmedCount.get(name.trim()) ?? 0) > 1) ? 'name_collides_after_trim' : flaw;
+            dropped.push({ name, reason, notice: dropNotice(name, reason, undefined, opts) });
+            continue;
+        }
+        const out = mcpConfigEntry(name, c);
+        if (out.spec !== null) {
+            specs.push(out.spec);
+            continue;
+        }
+        if (out.axesProblem !== undefined) {
+            dropped.push({ name, reason: 'tool_axes_invalid', problem: out.axesProblem, notice: dropNotice(name, 'tool_axes_invalid', out.axesProblem, opts) });
+        }
+        else if (out.elicitationInvalid === true) {
+            dropped.push({ name, reason: 'elicitation_invalid', notice: dropNotice(name, 'elicitation_invalid', undefined, opts) });
+        }
+    }
+    return { specs, dropped: Object.freeze(dropped) };
+}
+function assertionDeclaringServerName(spec) {
+    const t = spec?.transport;
+    if (t?.kind !== 'http')
+        return undefined;
+    const declared = t.assertionHeader;
+    return typeof declared === 'string' && declared.length > 0 && typeof spec?.name === 'string' ? spec.name : undefined;
+}
+const ASSERTION_NOTICE_NAMES_SHOWN = 5;
+export function mcpAssertionHeaderNotSentNotice(specs) {
+    const count = guardedRead(() => (Array.isArray(specs) ? specs.length : 0)) ?? 0;
+    const names = [];
+    for (let i = 0; i < count; i++) {
+        const name = guardedRead(() => assertionDeclaringServerName(specs[i]));
+        if (name !== undefined)
+            names.push(name);
     }
-    return out;
+    if (names.length === 0)
+        return undefined;
+    const distinct = [...new Set(names)];
+    const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
+    if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
+        parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.131.0 accept this setting but do not send the header, ` +
+        'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/memoryEntriesWire.d.ts

@@ -1,10 +1,11 @@
-export type MemoryEntryOriginMark = 'marked' | 'unmarked' | 'undecidable';
+import type { MemoryErasedBinding } from '@sema-agent/sdk';
+export type MemoryEntryOriginMarkReading = 'marked' | 'unmarked' | 'undecidable';
 export interface MemoryExportEntryRow {
     id: string;
     slug: string;
     scope: string;
     rev: string;
-    originMark: MemoryEntryOriginMark;
+    originMark: MemoryEntryOriginMarkReading;
 }
 export type MemoryExportUnreadableCause = 'body_unreadable' | 'envelope_absent' | 'envelope_unreadable' | 'too_many_rows' | 'rows_unreadable';
 export type MemoryExportReading = {
@@ -36,13 +37,7 @@ export type ScopeExternalOriginVerdict = {
 export declare function scopeExternalOriginVerdict(reading: MemoryExportReading, asked: {
     originAware: boolean;
 }): ScopeExternalOriginVerdict;
-export type MemoryErasedBinding = {
-    state: 'bound';
-    scope: string;
-    slug: string;
-} | {
-    state: 'unbound';
-};
+export type { MemoryErasedBinding };
 export interface MemoryErasedRow {
     id: string;
     rev: string;

package/dist/memoryEntriesWire.js

@@ -1,3 +1,4 @@
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
 function nonEmptyString(v) {
     return typeof v === 'string' && v !== '';
 }
@@ -216,16 +217,10 @@ export function readMemoryEraseReceipt(body) {
             return { kind: 'malformed', why: 'body_unreadable' };
         o = body;
         envelopeSeen = ['v', 'requestId', 'status', 'erased', 'notFound'].some((k) => Object.hasOwn(o, k));
-        rawV = Object.hasOwn(o, 'v') ? o.v : undefined;
-        rawRequestId = o.requestId;
-        rawStatus = o.status;
-        rawEvidence = o.evidenceCapability;
-        rawCustody = o.custodyState;
-        rawSelected = o.resolvedIds;
-        rawErased = o.erased;
-        rawNotFound = o.notFound;
-        rawPreviously = Object.hasOwn(o, 'erasedPreviously') ? o.erasedPreviously : undefined;
-        rawConflicts = o.conflicts;
+        const slots = ['v', 'requestId', 'status', 'evidenceCapability', 'custodyState', 'resolvedIds', 'erased', 'notFound', 'erasedPreviously', 'conflicts'].map((k) => readThrownSlot(o, k, 'data'));
+        if (slots.includes(THROWN_SLOT_UNREADABLE))
+            return { kind: 'malformed', why: 'body_unreadable' };
+        [rawV, rawRequestId, rawStatus, rawEvidence, rawCustody, rawSelected, rawErased, rawNotFound, rawPreviously, rawConflicts] = slots;
     }
     catch {
         return { kind: 'malformed', why: 'body_unreadable' };

package/dist/model/modelSupplyRules.d.ts

@@ -25,7 +25,6 @@ export interface TierGroupsView {
 export interface DeleteWarningsInput {
     id: string;
     doc: {
-        atModelAllowlist?: unknown;
         atMention?: unknown;
         tierGroups?: unknown;
     } | null;
@@ -35,7 +34,6 @@ export interface DeleteWarningsInput {
 export interface DeleteBlockersInput {
     id: string;
     doc: {
-        default?: unknown;
         roles?: unknown;
     } | null;
     rosters: {

package/dist/model/modelSupplyRules.js

@@ -22,9 +22,7 @@ export function computeDeleteWarnings(input) {
         if (before.mode === 'only' && after.mode === 'none') {
             out.push({
                 kind: 'allowlist-empties',
-                consequence: am.from === 'atModelAllowlist'
-                    ? 'it is the last usable model on your @-mention allowlist — deleting it empties the list, which means EVERY enabled model becomes @-mentionable'
-                    : 'it is the last usable model on your @-mention allowlist — deleting it leaves no model that can be @-mentioned',
+                consequence: 'it is the last usable model on your @-mention allowlist — deleting it leaves no model that can be @-mentioned',
             });
         }
     }
@@ -58,24 +56,17 @@ export function computeDeleteBlockers(input) {
             fix: 'fix or re-save models.json so it can be read, then delete this model',
         });
     }
-    if (policy.defaultUnreadable) {
-        out.push({
-            kind: 'unreadable',
-            where: 'models.json `default` (the default model could not be read)',
-            fix: 'fix or re-save models.json so its default model can be read, then delete this model',
-        });
-    }
     const dm = policy.defaultModel;
     if (dm !== undefined && dm.name === id) {
         out.push({
             kind: 'default',
-            where: dm.from === 'default' ? 'models.json `default`' : 'models.json roles.default',
+            where: 'models.json roles.default',
             fix: 'point another model at the default first (Model Hub: select it and press u), then delete this one',
         });
     }
     if (doc && isPlainObject(doc.roles)) {
         for (const [role, target] of Object.entries(doc.roles)) {
-            if (role === 'default' && dm?.from === 'roles.default')
+            if (role === 'default' && dm !== undefined)
                 continue;
             if (!isPlainObject(target) || typeof target.model !== 'string')
                 continue;

package/dist/model/modelsPolicy.d.ts

@@ -1,20 +1,15 @@
 import { type SettingsAtMention } from '../generated/settingsSchemaFns.js';
 export interface CanonicalDefaultModel {
     readonly name: string;
-    readonly from: 'default' | 'roles.default';
 }
 export type CanonicalAtMention = {
     readonly kind: 'read';
     readonly value: SettingsAtMention;
-    readonly from: 'atMention' | 'atModelAllowlist';
-    readonly unreadableEntries: number;
 } | {
     readonly kind: 'unreadable';
-    readonly from: 'atMention' | 'atModelAllowlist';
 };
 export interface CanonicalModelsPolicy {
     readonly defaultModel?: CanonicalDefaultModel;
-    readonly defaultUnreadable?: true;
     readonly atMention?: CanonicalAtMention;
     readonly unreadable?: true;
 }