@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/mcpWireCaps.js

@@ -1,17 +1,17 @@
 import { SETTINGS_DESCRIBE_BAD_WIRE_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_MCP_IDENTITY_HEADERS, SETTINGS_READ_REQUEST_MCP_TRANSPORT, } from './generated/settingsSchemaFns.js';
 import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
-import { guardedRead } from './ownKey.js';
-import { readMcpToolAxes } from './coreValuePorts.js';
+import { appendOwnElement, guardedRead } from './ownKey.js';
+import { readMcpToolAxes, readToolFaces } from './coreValuePorts.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const _mcpServerSpecPin = true;
 void _mcpServerSpecPin;
-function transparentKeys(c, axes, elicitation) {
+function transparentKeys(startupTimeoutMs, axes, faces, elicitation) {
     return {
-        ...(c.toolFaces !== undefined ? { toolFaces: c.toolFaces } : {}),
+        ...(faces !== undefined ? { toolFaces: faces } : {}),
         ...(axes !== undefined ? { toolAxes: axes } : {}),
         ...(elicitation !== undefined ? { elicitation } : {}),
-        ...(c.startupTimeoutMs !== undefined ? { startupTimeoutMs: c.startupTimeoutMs } : {}),
+        ...(startupTimeoutMs !== undefined ? { startupTimeoutMs } : {}),
     };
 }
 export function readMcpHttpIdentityHeaders(transport) {
@@ -25,24 +25,75 @@ export function readMcpHttpIdentityHeaders(transport) {
 export function mcpConfigToSpec(name, c) {
     return mcpConfigEntry(name, c).spec;
 }
+function entryShapeOf(c) {
+    try {
+        return typeof c === 'object' && c !== null && !Array.isArray(c) ? 'object' : 'not_object';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function readEntryOwnKeys(c) {
+    try {
+        const allowTools = c.allowTools;
+        return { toolAxes: c.toolAxes, elicitation: c.elicitation, allowTools, startupTimeoutMs: c.startupTimeoutMs };
+    }
+    catch {
+        return undefined;
+    }
+}
 function mcpConfigEntry(name, c) {
     if (!nameUsable(name))
         return { spec: null };
-    const declared = c.toolAxes;
+    const shape = entryShapeOf(c);
+    if (shape === 'not_object')
+        return { spec: null, entryNotObject: true };
+    if (shape === 'unreadable')
+        return { spec: null, entryUnreadable: true };
+    const own = readEntryOwnKeys(c);
+    if (own === undefined) {
+        const t = transportOf(c);
+        if (t.kind === 'skip')
+            return { spec: null };
+        if (t.kind === 'both_set')
+            return { spec: null, identityBothSet: true };
+        if (t.kind === 'bad')
+            return { spec: null, transportBad: t.issue };
+        return { spec: null, entryUnreadable: true };
+    }
+    const declared = own.toolAxes;
     const verdict = mcpToolAxesVerdict(declared);
-    const elDeclared = c.elicitation;
+    let facesDeclared;
+    let facesUnreadable = false;
+    try {
+        facesDeclared = c.toolFaces;
+    }
+    catch {
+        facesUnreadable = true;
+    }
+    const facesVerdict = facesUnreadable
+        ? Object.freeze({ kind: 'bad', problem: renderMessage(msg('config.mcp.toolFacesUnreadable')) })
+        : mcpToolFacesVerdict(facesDeclared);
+    const elDeclared = own.elicitation;
     const elVerdict = mcpElicitationVerdict(elDeclared);
-    if (verdict.kind === 'bad' || elVerdict.kind === 'bad') {
-        const rest = specOf(name, c, undefined, undefined);
+    const allowVerdict = mcpAllowToolsVerdict(() => own.allowTools, `mcpServers.${capForDisplay(name, DROP_NAME_SHOWN)}.`);
+    if (verdict.kind === 'bad' || facesVerdict.kind === 'bad' || elVerdict.kind === 'bad' || allowVerdict.kind === 'bad') {
+        const rest = specOf(name, c, own, undefined, undefined, undefined, undefined);
         if (rest.kind === 'skip')
             return { spec: null };
         if (rest.kind === 'both_set')
             return { spec: null, identityBothSet: true };
         if (rest.kind === 'bad')
             return { spec: null, transportBad: rest.issue };
-        return verdict.kind === 'bad' ? { spec: null, axesProblem: verdict.problem } : { spec: null, elicitationInvalid: true };
+        if (verdict.kind === 'bad')
+            return { spec: null, axesProblem: verdict.problem };
+        if (facesVerdict.kind === 'bad')
+            return { spec: null, facesProblem: facesVerdict.problem };
+        if (elVerdict.kind === 'bad')
+            return { spec: null, elicitationInvalid: true };
+        return allowVerdict.kind === 'bad' ? { spec: null, allowToolsInvalid: { path: allowVerdict.path, problem: allowVerdict.problem } } : { spec: null };
     }
-    const read = specOf(name, c, verdict.kind === 'ok' ? verdict.toolAxes : declared, elVerdict.elicitation);
+    const read = specOf(name, c, own, verdict.kind === 'ok' ? verdict.toolAxes : declared, facesVerdict.kind === 'ok' ? facesVerdict.toolFaces : facesDeclared, elVerdict.elicitation, allowVerdict.allowTools);
     if (read.kind === 'skip')
         return { spec: null };
     if (read.kind === 'both_set')
@@ -51,7 +102,7 @@ function mcpConfigEntry(name, c) {
         return { spec: null, transportBad: read.issue };
     return { spec: read.spec, ...(read.lost.length > 0 ? { transportLost: read.lost } : {}) };
 }
-function specOf(name, c, axes, elicitation) {
+function transportOf(c) {
     let candidate;
     try {
         const kind = c.type ?? 'stdio';
@@ -78,18 +129,49 @@ function specOf(name, c, axes, elicitation) {
         }
     }
     catch {
-        return { kind: 'bad', issue: { path: 'transport', reason: renderMessage(msg('config.mcp.transportUnreadable')) } };
+        return transportUnreadableRead();
+    }
+    let read;
+    try {
+        read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
+    }
+    catch {
+        return transportUnreadableRead();
     }
-    const read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
     if (!read.ok)
         return { kind: 'bad', issue: read.issue };
+    return { kind: 'ok', transport: wireTransportOf(read.transport), lost: read.lost };
+}
+function transportUnreadableRead() {
+    return { kind: 'bad', issue: { path: 'transport', reason: renderMessage(msg('config.mcp.transportUnreadable')) } };
+}
+function specOf(name, c, own, axes, faces, elicitation, allowTools) {
+    const t = transportOf(c);
+    if (t.kind !== 'ok')
+        return t;
     const spec = {
         name,
-        transport: wireTransportOf(read.transport),
-        ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
-        ...transparentKeys(c, axes, elicitation),
+        transport: t.transport,
+        ...(allowTools !== undefined ? { allowTools } : {}),
+        ...transparentKeys(own.startupTimeoutMs, axes, faces, elicitation),
     };
-    return { kind: 'ok', spec, lost: read.lost };
+    return { kind: 'ok', spec, lost: t.lost };
+}
+export function mcpTransportVerdict(entry) {
+    const shape = entryShapeOf(entry);
+    if (shape !== 'object')
+        return transportBadVerdict('transport', renderMessage(msg(shape === 'not_object' ? 'config.mcp.entryNotObjectProblem' : 'config.mcp.transportUnreadable')));
+    const t = transportOf(entry);
+    if (t.kind === 'ok')
+        return Object.freeze({ kind: 'ok', transport: t.transport, lost: Object.freeze([...t.lost]) });
+    if (t.kind === 'bad')
+        return transportBadVerdict(t.issue.path, t.issue.reason);
+    if (t.kind === 'both_set')
+        return transportBadVerdict('transport', renderMessage(msg('config.mcp.transportIdentityBothSetProblem')));
+    return transportBadVerdict('transport.kind', renderMessage(msg('config.mcp.transportTypeUnsupported')));
+}
+function transportBadVerdict(key, detail) {
+    return Object.freeze({ kind: 'bad', key, detail });
 }
 export function mcpConfigsToSpecs(servers) {
     return projectMcpConfigs(servers).specs;
@@ -110,17 +192,115 @@ export function mcpToolAxesVerdict(declared) {
     }
     return Object.freeze({ kind: 'unavailable' });
 }
+export function mcpToolFacesVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    const read = readToolFaces(declared);
+    if (read === undefined || read === null || typeof read !== 'object')
+        return Object.freeze({ kind: 'unavailable' });
+    if (read.ok === true) {
+        const copy = read.faces;
+        return Object.freeze(typeof copy === 'object' && copy !== null ? { kind: 'ok', toolFaces: 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.toolFacesFallbackProblem')) });
+    }
+    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' });
 }
+const ALLOW_TOOLS_READ_BUDGET = 100_000;
+export function mcpAllowToolsVerdict(read, keyPrefix = '') {
+    const bad = (path, key, got) => Object.freeze({ kind: 'bad', path, problem: renderMessage(msg(key, { path: `${keyPrefix}${path}`, got: got ?? '' })) });
+    let declared;
+    try {
+        declared = read();
+    }
+    catch {
+        return bad('allowTools', 'config.mcp.allowToolsUnreadable');
+    }
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    try {
+        if (!Array.isArray(declared))
+            return bad('allowTools', 'config.mcp.allowToolsNotArray', declared === null ? 'null' : typeof declared);
+        const lengthDesc = Object.getOwnPropertyDescriptor(declared, 'length');
+        const length = lengthDesc !== undefined && Object.hasOwn(lengthDesc, 'value') ? lengthDesc.value : undefined;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+            return bad('allowTools', 'config.mcp.allowToolsUnreadable');
+        if (length > ALLOW_TOOLS_READ_BUDGET)
+            return bad('allowTools', 'config.mcp.allowToolsTooMany', String(ALLOW_TOOLS_READ_BUDGET));
+        const copy = [];
+        for (let i = 0; i < length; i++) {
+            const d = Object.getOwnPropertyDescriptor(declared, String(i));
+            if (d === undefined)
+                return bad(`allowTools[${i}]`, 'config.mcp.allowToolsHole');
+            if (!Object.hasOwn(d, 'value'))
+                return bad(`allowTools[${i}]`, 'config.mcp.allowToolsUnreadable');
+            const el = d.value;
+            if (typeof el !== 'string')
+                return bad(`allowTools[${i}]`, 'config.mcp.allowToolsElementNotString', el === null ? 'null' : Array.isArray(el) ? 'array' : typeof el);
+            appendOwnElement(copy, el);
+        }
+        return Object.freeze({ kind: 'ok', allowTools: copy });
+    }
+    catch {
+        return bad('allowTools', 'config.mcp.allowToolsUnreadable');
+    }
+}
 const nameUsable = (name) => SETTINGS_IS_USABLE_WIRE_NAME(name);
 function mcpNameDropReasonOf(name) {
     if (typeof name !== 'string' || name.trim().length === 0)
         return 'name_blank';
     return name.trim() !== name ? 'name_edge_whitespace' : 'name_too_long';
 }
+const _nameReasonsPin = true;
+void _nameReasonsPin;
+function nameSiblingsOf(siblings) {
+    if (siblings === undefined || siblings === null)
+        return undefined;
+    if (typeof siblings[Symbol.iterator] !== 'function') {
+        throw new TypeError('mcpServerNameVerdict: siblings must be an iterable of server names (or absent)');
+    }
+    const usable = new Set();
+    const variants = new Map();
+    for (const entry of siblings) {
+        const sibling = entry;
+        if (typeof sibling !== 'string')
+            continue;
+        if (nameUsable(sibling))
+            usable.add(sibling);
+        else if (mcpNameDropReasonOf(sibling) === 'name_edge_whitespace') {
+            const trimmed = sibling.trim();
+            const set = variants.get(trimmed);
+            if (set === undefined)
+                variants.set(trimmed, new Set([sibling]));
+            else
+                set.add(sibling);
+        }
+    }
+    return { usable, variants };
+}
+function nameVerdictAmong(name, among) {
+    if (nameUsable(name))
+        return Object.freeze({ usable: true });
+    const reason = mcpNameDropReasonOf(name);
+    if (reason === 'name_edge_whitespace' && among !== undefined && typeof name === 'string') {
+        const trimmed = name.trim();
+        const others = among.variants.get(trimmed);
+        if (among.usable.has(trimmed) || (others !== undefined && (others.size > 1 || !others.has(name)))) {
+            return Object.freeze({ usable: false, reason: 'name_collides_after_trim' });
+        }
+    }
+    return Object.freeze({ usable: false, reason });
+}
+export function mcpServerNameVerdict(name, siblings) {
+    return nameVerdictAmong(name, nameSiblingsOf(siblings));
+}
 const DROP_NAME_SHOWN = 80;
 const DROP_LABEL_SHOWN = 140;
 const DROP_PROBLEM_SHOWN = 300;
@@ -137,21 +317,29 @@ function dropNotice(name, reason, problem, opts, path) {
     const where = typeof label === 'string' && label.length > 0 ? ` (${capForDisplay(label, DROP_LABEL_SHOWN)})` : '';
     const quoted = `"${capForDisplay(name, DROP_NAME_SHOWN)}"`;
     const badName = () => capForDisplay(SETTINGS_DESCRIBE_BAD_WIRE_NAME(name), DROP_BAD_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 === 'identity_headers_both_set'
-                ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
-                : reason === 'transport_invalid'
-                    ? msg('config.mcp.transportInvalid', { name: quoted, where, path: capForDisplay(path ?? 'transport', DROP_NAME_SHOWN), problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
-                    : reason === 'name_blank'
-                        ? msg('config.mcp.nameBlank', { name: badName(), where })
-                        : reason === 'name_collides_after_trim'
-                            ? msg('config.mcp.nameCollides', { name: badName(), where })
-                            : reason === 'name_too_long'
-                                ? msg('config.mcp.nameTooLong', { name: badName(), where })
-                                : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
+    const ref = reason === 'entry_not_object'
+        ? msg('config.mcp.entryNotObject', { name: quoted, where })
+        : reason === 'entry_unreadable'
+            ? msg('config.mcp.entryUnreadable', { name: quoted, where })
+            : reason === 'tool_axes_invalid'
+                ? msg('config.mcp.toolAxesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolAxesFallbackProblem')), DROP_PROBLEM_SHOWN) })
+                : reason === 'tool_faces_invalid'
+                    ? msg('config.mcp.toolFacesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolFacesFallbackProblem')), DROP_PROBLEM_SHOWN) })
+                    : reason === 'elicitation_invalid'
+                        ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
+                        : reason === 'allow_tools_invalid'
+                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                            : reason === 'identity_headers_both_set'
+                                ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
+                                : reason === 'transport_invalid'
+                                    ? msg('config.mcp.transportInvalid', { name: quoted, where, path: capForDisplay(path ?? 'transport', DROP_NAME_SHOWN), problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                                    : reason === 'name_blank'
+                                        ? msg('config.mcp.nameBlank', { name: badName(), where })
+                                        : reason === 'name_collides_after_trim'
+                                            ? msg('config.mcp.nameCollides', { name: badName(), where })
+                                            : reason === 'name_too_long'
+                                                ? msg('config.mcp.nameTooLong', { name: badName(), where })
+                                                : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
     return renderMessage(ref, opts?.lang);
 }
 function degradedNotice(name, lost, opts) {
@@ -167,34 +355,43 @@ function degradedNotice(name, lost, opts) {
     const what = capForDisplay(lost.map((l) => `${l.path}: ${l.reason}`).join('; '), DEGRADED_LOST_SHOWN);
     return renderMessage(msg('config.mcp.transportDegraded', { name: quoted, where, lost: what }), opts?.lang);
 }
+function entriesOf(servers) {
+    const table = servers ?? {};
+    return Object.keys(table).map((name) => {
+        try {
+            return [name, table[name], false];
+        }
+        catch {
+            return [name, undefined, true];
+        }
+    });
+}
 export function projectMcpConfigs(servers, opts) {
     const specs = [];
     const dropped = [];
     const degraded = [];
-    const entries = Object.entries(servers ?? {});
-    const exactNames = new Set();
-    const trimmedCount = new Map();
-    for (const [name] of entries) {
-        if (nameUsable(name))
-            exactNames.add(name);
-        else if (mcpNameDropReasonOf(name) === 'name_edge_whitespace')
-            trimmedCount.set(name.trim(), (trimmedCount.get(name.trim()) ?? 0) + 1);
-    }
-    for (const [name, c] of entries) {
-        if (!nameUsable(name)) {
-            const flaw = mcpNameDropReasonOf(name);
-            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) });
+    const entries = entriesOf(servers);
+    const among = nameSiblingsOf(entries.map(([name]) => name));
+    for (const [name, c, slotUnreadable] of entries) {
+        const nameVerdict = nameVerdictAmong(name, among);
+        if (!nameVerdict.usable) {
+            dropped.push({ name, reason: nameVerdict.reason, notice: dropNotice(name, nameVerdict.reason, undefined, opts) });
             continue;
         }
-        const out = mcpConfigEntry(name, c);
+        const out = slotUnreadable ? { spec: null, entryUnreadable: true } : mcpConfigEntry(name, c);
         if (out.spec !== null) {
             specs.push(out.spec);
             if (out.transportLost !== undefined)
                 degraded.push({ name, lost: Object.freeze([...out.transportLost]), notice: degradedNotice(name, out.transportLost, opts) });
             continue;
         }
-        if (out.identityBothSet === true) {
+        if (out.entryNotObject === true) {
+            dropped.push({ name, reason: 'entry_not_object', notice: dropNotice(name, 'entry_not_object', undefined, opts) });
+        }
+        else if (out.entryUnreadable === true) {
+            dropped.push({ name, reason: 'entry_unreadable', notice: dropNotice(name, 'entry_unreadable', undefined, opts) });
+        }
+        else if (out.identityBothSet === true) {
             dropped.push({ name, reason: 'identity_headers_both_set', notice: dropNotice(name, 'identity_headers_both_set', undefined, opts) });
         }
         else if (out.transportBad !== undefined) {
@@ -204,9 +401,16 @@ export function projectMcpConfigs(servers, opts) {
         else 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.facesProblem !== undefined) {
+            dropped.push({ name, reason: 'tool_faces_invalid', problem: out.facesProblem, notice: dropNotice(name, 'tool_faces_invalid', out.facesProblem, opts) });
+        }
         else if (out.elicitationInvalid === true) {
             dropped.push({ name, reason: 'elicitation_invalid', notice: dropNotice(name, 'elicitation_invalid', undefined, opts) });
         }
+        else if (out.allowToolsInvalid !== undefined) {
+            const { path, problem } = out.allowToolsInvalid;
+            dropped.push({ name, reason: 'allow_tools_invalid', problem, path, notice: dropNotice(name, 'allow_tools_invalid', problem, opts, path) });
+        }
     }
     return { specs, dropped: Object.freeze(dropped), degraded: Object.freeze(degraded) };
 }
@@ -232,6 +436,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     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.132.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.134.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/memoryComplianceCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export const MEMORY_ENGINE_REQUIRED_CODE = 'capability.memory_engine_required';
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'memoryCompliance',
     project: projectMemoryComplianceCapability,
 });
-export function observedMemoryCompliance(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedMemoryCompliance(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function memoryComplianceVerbsAvailable(reading) {

package/dist/memoryOriginCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 import { MEMORY_ENGINE_REQUIRED_CODE } from './memoryComplianceCapability.js';
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'memoryOrigin',
     project: projectMemoryOriginCapability,
 });
-export function observedMemoryOrigin(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedMemoryOrigin(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function memoryOriginVerbsAvailable(reading) {

package/dist/model/catalogDefault.d.ts

@@ -0,0 +1,24 @@
+import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL, type SETTINGS_DEFAULT_ROLE_TIER_LADDER } from '../generated/settingsSchemaFns.js';
+export type CatalogDefaultModelsInput = Parameters<typeof SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL>[0];
+export type CatalogDefaultSource = 'roles.default' | 'fallback' | `tierGroup.${(typeof SETTINGS_DEFAULT_ROLE_TIER_LADDER)[number]}`;
+export interface CatalogDefaultDangling {
+    readonly source: Exclude<CatalogDefaultSource, 'fallback'>;
+    readonly name: string;
+}
+export interface CatalogDefaultSelectCriteria {
+    readonly tier?: string | undefined;
+    readonly needs?: readonly string[] | undefined;
+    readonly prefer?: string | undefined;
+}
+export interface CatalogDefaultNamed {
+    readonly kind: 'named';
+    readonly name: string;
+    readonly source: CatalogDefaultSource;
+    readonly dangling: readonly CatalogDefaultDangling[];
+}
+export interface CatalogDefaultSelect {
+    readonly kind: 'select';
+    readonly select: CatalogDefaultSelectCriteria;
+}
+export type CatalogDefaultModel = CatalogDefaultNamed | CatalogDefaultSelect;
+export declare function resolveCatalogDefaultModel(models: CatalogDefaultModelsInput, has: (name: string) => boolean, fallback: string): CatalogDefaultModel;

package/dist/model/catalogDefault.js

@@ -0,0 +1,4 @@
+import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL } from '../generated/settingsSchemaFns.js';
+export function resolveCatalogDefaultModel(models, has, fallback) {
+    return SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL(models, has, fallback);
+}

package/dist/model/liveCatalogShape.js

@@ -14,22 +14,23 @@ function frozenJsonCopy(v, depth) {
     if (typeof v !== 'object')
         throw new Unreadable();
     if (Array.isArray(v)) {
-        const n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+        const ld = Object.getOwnPropertyDescriptor(v, 'length');
+        const n = ld !== undefined && Object.hasOwn(ld, 'value') ? ld.value : undefined;
         if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
             throw new Unreadable();
         const out = [];
         for (let i = 0; i < n; i += 1) {
             const d = Object.getOwnPropertyDescriptor(v, String(i));
-            if (d === undefined || !('value' in d))
+            if (d === undefined || !Object.hasOwn(d, 'value'))
                 throw new Unreadable();
-            out.push(frozenJsonCopy(d.value, depth + 1));
+            Object.defineProperty(out, out.length, { value: frozenJsonCopy(d.value, depth + 1), writable: true, enumerable: true, configurable: true });
         }
         return Object.freeze(out);
     }
     const out = {};
     for (const k of Object.keys(v)) {
         const d = Object.getOwnPropertyDescriptor(v, k);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             throw new Unreadable();
         if (d.value === undefined)
             continue;

package/dist/model/modelsPolicy.js

@@ -1,8 +1,9 @@
+import { appendOwnElement } from '../ownKey.js';
 import { SETTINGS_AT_MENTION_MODES } from '../generated/settingsSchemaFns.js';
 function ownData(o, key) {
     try {
         const d = Object.getOwnPropertyDescriptor(o, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;
@@ -24,9 +25,9 @@ function atMentionOf(v) {
         const out = [];
         for (let i = 0; i < list.length; i += 1) {
             const d = Object.getOwnPropertyDescriptor(list, i);
-            if (d === undefined || !('value' in d) || typeof d.value !== 'string' || d.value.length === 0)
+            if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string' || d.value.length === 0)
                 return undefined;
-            out.push(d.value);
+            appendOwnElement(out, d.value);
         }
         return { mode: 'only', models: out };
     }

package/dist/model/onboardJudgement.d.ts

@@ -50,6 +50,7 @@ export type OnboardWriteVerdict = {
     readonly refusal: 'probe_failed' | 'probe_unverified';
 };
 export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict, acceptUnverified?: boolean): OnboardWriteVerdict;
+export declare const KEY_SLOT_PREFIX = "SEMA_MODEL_KEY_";
 export declare function keyEnvNameForEntry(entryName: string): string;
 export declare function poolEntryNameOf(modelId: string, channel: string, taken: ReadonlySet<string>): string;
 export interface OnboardPlanEntry {

package/dist/model/onboardJudgement.js

@@ -206,7 +206,7 @@ export function onboardWriteVerdict(verdict, acceptUnverified) {
         return Object.freeze({ write: false, refusal: 'probe_failed' });
     return acceptUnverified === true ? Object.freeze({ write: true, unverified: true }) : Object.freeze({ write: false, refusal: 'probe_unverified' });
 }
-const KEY_SLOT_PREFIX = 'SEMA_MODEL_KEY_';
+export const KEY_SLOT_PREFIX = 'SEMA_MODEL_KEY_';
 export function keyEnvNameForEntry(entryName) {
     const base = String(entryName).toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'ENTRY';
     return `${KEY_SLOT_PREFIX}${base}`;

package/dist/model/subagentModelWord.js

@@ -8,7 +8,7 @@ function ownData(v, key) {
         return undefined;
     try {
         const d = Object.getOwnPropertyDescriptor(v, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;
@@ -74,7 +74,7 @@ function ownSlot(v, key) {
         const d = Object.getOwnPropertyDescriptor(v, key);
         if (d === undefined)
             return { kind: 'absent' };
-        return 'value' in d ? { kind: 'value', value: d.value } : { kind: 'unreadable' };
+        return Object.hasOwn(d, 'value') ? { kind: 'value', value: d.value } : { kind: 'unreadable' };
     }
     catch {
         return { kind: 'unreadable' };

package/dist/modelCapabilityProbe.js

@@ -1,5 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { abortableSleep } from './abortableSleep.js';
+import { causeSlotProtected, walkCauseChain } from './engineWireFor.js';
 import { readThrownSlot } from './wireFailureShape.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
 import { msg, renderMessage } from './i18n/translate.js';
@@ -467,18 +468,17 @@ function nearestFromCatalogText(text, modelId) {
 }
 function unwrapFetchCause(e) {
     const parts = [];
-    let cur = e;
-    for (let i = 0; i < 4 && cur !== null && typeof cur === 'object'; i++) {
-        const code = readThrownSlot(cur, 'code');
-        const message = readThrownSlot(cur, 'message');
+    walkCauseChain(e, (layer) => {
+        const code = readThrownSlot(layer, 'code');
+        const message = readThrownSlot(layer, 'message');
         const c = typeof code === 'string' && code !== '' ? code : undefined;
         const m = typeof message === 'string' && message !== '' ? message : undefined;
         if (c !== undefined)
             parts.push(m !== undefined && m !== c ? `${c} ${m}` : c);
         else if (m !== undefined)
             parts.push(m);
-        cur = readThrownSlot(cur, 'cause');
-    }
+        return undefined;
+    }, causeSlotProtected);
     if (parts.length === 0 && typeof e === 'string')
         parts.push(e);
     return [...new Set(parts)].join(' ← ');

package/dist/modelIdentityResolvability.d.ts

@@ -17,8 +17,11 @@ export interface LocalEngineModelIdentityReading {
     engine: 'local';
     lanes: ModelIdentityLanes;
     engineAnswer?: EngineAnswerObservation;
-    engineAcceptsCatalogDefault?: boolean;
     catalogAdoption?: EngineCatalogAdoptionReading;
+    catalogFacts?: {
+        readonly listed?: number;
+        readonly shapeRefused?: boolean;
+    };
     routeGap?: ModelRouteGapReading;
 }
 export type ModelRouteGapReading = 'endpoint_missing' | 'lane_credential_missing' | 'none';
@@ -30,6 +33,12 @@ export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngin
 export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
 export type ModelSetupDecision = 'offer_setup' | 'offer_route_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'explain_route_unconfigurable' | 'proceed';
 export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
+export interface ModelIdentityCatalogDeviation {
+    readonly kind: 'catalog_lane_overridden_by_facts';
+    readonly reported: ModelIdentityLaneReading | 'unusable';
+    readonly derived: 'partial' | 'absent';
+}
+export declare function modelIdentityCatalogDeviationOf(reading: ModelIdentityReading): ModelIdentityCatalogDeviation | undefined;
 export declare function modelRouteGapSentence(lane: ModelIdentityLane, gap: ModelRouteGapReading, lang?: UiLanguage): string | undefined;
 export declare function modelRouteGapFact(gap: ModelRouteGapReading, lang?: UiLanguage): string | undefined;
 export declare function modelIdentityDetail(reading: ModelIdentityReading): string;