@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/cloudConfigWireCaps.js

@@ -1,5 +1,5 @@
-import { mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
-import { toCappedSpec } from './skillsWireCaps.js';
+import { mcpAllowToolsVerdict, mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, mcpToolFacesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
+import { skillToolListsVerdict, toCappedSpec } from './skillsWireCaps.js';
 import { SETTINGS_DESCRIBE_BAD_WIRE_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_REQUEST_MCP_TRANSPORT } from './generated/settingsSchemaFns.js';
 import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
 import { msg, renderMessage } from './i18n/translate.js';
@@ -18,23 +18,56 @@ export function cloudMcpToSpecs(servers, env) {
     const missingEnv = [];
     const droppedServers = [];
     const degradedServers = [];
-    const drop = (name, reason, path) => {
-        droppedServers.push({ ...(name ? { name } : {}), reason, ...(path !== undefined ? { path } : {}) });
+    const recordDrop = (name, reason, path, problem) => {
+        droppedServers.push({ ...(name ? { name } : {}), reason, ...(path !== undefined ? { path } : {}), ...(problem !== undefined ? { problem } : {}) });
     };
     for (const raw of asArr(servers)) {
-        const s = asRec(raw);
-        const name = s ? asStr(s.name) : undefined;
-        if (!s || s.enabled === false) {
-            drop(name, s?.enabled === false ? 'disabled' : 'missing-field');
+        let s;
+        try {
+            s = asRec(raw);
+        }
+        catch {
+            recordDrop(undefined, 'entry-unreadable');
+            continue;
+        }
+        let name;
+        try {
+            name = s ? asStr(s.name) : undefined;
+        }
+        catch {
+            recordDrop(undefined, 'entry-unreadable');
+            continue;
+        }
+        if (!s) {
+            recordDrop(name, 'missing-field');
+            continue;
+        }
+        let enabled;
+        try {
+            enabled = s.enabled;
+        }
+        catch {
+            recordDrop(name, 'entry-unreadable');
+            continue;
+        }
+        if (enabled === false) {
+            recordDrop(name, 'disabled');
+            continue;
+        }
+        let t;
+        try {
+            t = asRec(s.transport);
+        }
+        catch {
+            recordDrop(name, 'entry-unreadable');
             continue;
         }
-        const t = asRec(s.transport);
         if (!name || !t) {
-            drop(name, 'missing-field');
+            recordDrop(name, 'missing-field');
             continue;
         }
         if (!SETTINGS_IS_USABLE_WIRE_NAME(name)) {
-            drop(name, 'name-unusable');
+            recordDrop(name, 'name-unusable');
             continue;
         }
         let candidate;
@@ -57,9 +90,9 @@ export function cloudMcpToSpecs(servers, env) {
         const dropHard = (issue, raw) => {
             const missing = (issue.path === 'transport.command' || issue.path === 'transport.url') && asStr(raw) === undefined;
             if (missing)
-                drop(name, 'missing-field');
+                recordDrop(name, 'missing-field');
             else
-                drop(name, 'transport-invalid', issue.path);
+                recordDrop(name, 'transport-invalid', issue.path);
         };
         try {
             if (t.kind === 'stdio') {
@@ -84,60 +117,103 @@ export function cloudMcpToSpecs(servers, env) {
                 const principalHeader = t.principalHeader;
                 const assertionHeader = t.assertionHeader;
                 if (readMcpHttpIdentityHeaders({ principalHeader, assertionHeader }).kind === 'both_set') {
-                    drop(name, 'principal-and-assertion-header');
+                    recordDrop(name, 'principal-and-assertion-header');
                     continue;
                 }
                 const headerEntries = resolveRefs(t.headerRefs);
                 candidate = { kind: 'http', url, headers: headerEntries.length > 0 ? Object.fromEntries(headerEntries) : undefined, principalHeader, assertionHeader };
             }
             else {
-                drop(name, 'unknown-transport');
+                recordDrop(name, 'unknown-transport');
                 continue;
             }
         }
         catch {
-            drop(name, 'transport-invalid', 'transport');
+            recordDrop(name, 'transport-invalid', 'transport');
+            continue;
+        }
+        let read;
+        try {
+            read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
+        }
+        catch {
+            recordDrop(name, 'transport-invalid', 'transport');
             continue;
         }
-        const read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
         if (!read.ok) {
             dropHard(read.issue, requiredRaw);
             continue;
         }
-        missingEnv.push(...missingHere);
         const transport = wireTransportOf(read.transport);
-        const axesDeclared = s.toolAxes;
+        let axesDeclared;
+        let elicitationDeclared;
+        let allowDeclared;
+        try {
+            axesDeclared = s.toolAxes;
+            elicitationDeclared = s.elicitation;
+            allowDeclared = s.allowTools;
+        }
+        catch {
+            recordDrop(name, 'entry-unreadable');
+            continue;
+        }
         const axesVerdict = mcpToolAxesVerdict(axesDeclared);
         if (axesVerdict.kind === 'bad') {
-            drop(name, 'tool-axes-invalid');
+            recordDrop(name, 'tool-axes-invalid');
             continue;
         }
         const axesShipped = axesVerdict.kind === 'ok' ? axesVerdict.toolAxes : axesDeclared;
-        const elVerdict = mcpElicitationVerdict(s.elicitation);
+        let facesDeclared;
+        let facesUnreadable = false;
+        try {
+            facesDeclared = s.toolFaces;
+        }
+        catch {
+            facesUnreadable = true;
+        }
+        const facesVerdict = facesUnreadable
+            ? Object.freeze({ kind: 'bad', problem: renderMessage(msg('config.mcp.toolFacesUnreadable')) })
+            : mcpToolFacesVerdict(facesDeclared);
+        if (facesVerdict.kind === 'bad') {
+            recordDrop(name, 'tool-faces-invalid', undefined, facesVerdict.problem);
+            continue;
+        }
+        const facesShipped = facesVerdict.kind === 'ok' ? facesVerdict.toolFaces : facesDeclared;
+        const elVerdict = mcpElicitationVerdict(elicitationDeclared);
         if (elVerdict.kind === 'bad') {
-            drop(name, 'elicitation-invalid');
+            recordDrop(name, 'elicitation-invalid');
             continue;
         }
-        const allowToolsWritten = Array.isArray(s.allowTools);
-        const allowTools = asArr(s.allowTools).filter((a) => typeof a === 'string');
+        const allowVerdict = mcpAllowToolsVerdict(() => allowDeclared, `config.mcp.servers.${capForDisplay(name, DEGRADED_NAME_SHOWN)}.`);
+        if (allowVerdict.kind === 'bad') {
+            recordDrop(name, 'allow-tools-invalid', allowVerdict.path, allowVerdict.problem);
+            continue;
+        }
+        missingEnv.push(...missingHere);
         if (read.lost.length > 0)
             degradedServers.push({ name, lost: Object.freeze([...read.lost]) });
         specs.push({
             name,
             transport,
-            ...(allowToolsWritten ? { allowTools } : {}),
+            ...(allowVerdict.allowTools !== undefined ? { allowTools: allowVerdict.allowTools } : {}),
             ...(elVerdict.elicitation !== undefined ? { elicitation: elVerdict.elicitation } : {}),
-            ...(s.toolFaces !== undefined ? { toolFaces: s.toolFaces } : {}),
+            ...(facesShipped !== undefined ? { toolFaces: facesShipped } : {}),
             ...(axesShipped !== undefined ? { toolAxes: axesShipped } : {}),
         });
     }
     return { specs, missingEnv: [...new Set(missingEnv)], droppedServers, degradedServers };
 }
-export function cloudSkillsToSpecs(manifestSkills, resolveBody) {
+export function cloudSkillsToSpecs(manifestSkills, resolveBody, opts) {
+    return projectCloudSkills(manifestSkills, resolveBody, opts).specs;
+}
+function projectCloudSkills(manifestSkills, resolveBody, opts) {
     const specs = [];
+    const dropped = [];
     const seen = new Set();
-    for (const raw of asArr(manifestSkills)) {
-        const s = asRec(raw);
+    const reading = opts?.skillToolLists;
+    const entries = asArr(manifestSkills);
+    for (let i = 0; i < entries.length; i++) {
+        const s = asRec(entries[i]);
         if (!s || s.enabled === false)
             continue;
         const name = asStr(s.name);
@@ -151,9 +227,14 @@ export function cloudSkillsToSpecs(manifestSkills, resolveBody) {
         if (!spec || seen.has(spec.name))
             continue;
         seen.add(spec.name);
-        specs.push(spec);
+        const verdict = skillToolListsVerdict(s, reading);
+        if (verdict.kind === 'bad') {
+            dropped.push({ name: spec.name, reason: 'tool-list-invalid', path: `skills[${i}].${verdict.key}${verdict.index !== undefined ? `[${verdict.index}]` : ''}` });
+            continue;
+        }
+        specs.push({ ...spec, ...verdict.lists });
     }
-    return specs;
+    return { specs, dropped };
 }
 const REGISTRY_ENTRY_ANNOTATION_KEYS = ['origin', 'overridesTeam'];
 function withoutRegistryAnnotations(e) {
@@ -237,7 +318,7 @@ function modelsDocOf(models, opts) {
     const acceptedFlags = accept ? stripped.map(acceptedName) : undefined;
     const names = acceptedFlags ? new Set(stripped.filter((_, i) => acceptedFlags[i]).map((e) => e.name)) : allNames;
     const issues = [...copyFailures];
-    const drop = (i) => {
+    const recordDrop = (i) => {
         issues.push({ ...i, outcome: 'dropped' });
     };
     const refOf = (v) => (typeof v === 'string' && v !== '' ? { target: v } : {});
@@ -258,13 +339,13 @@ function modelsDocOf(models, opts) {
     const doc = { models: written };
     const policy = modelsPolicyOf(m);
     if (policy.unreadable) {
-        drop({ key: 'roles', at: 'default', reason: 'unreadable' });
-        drop({ key: 'atMention', at: 'models', reason: 'unreadable' });
+        recordDrop({ key: 'roles', at: 'default', reason: 'unreadable' });
+        recordDrop({ key: 'atMention', at: 'models', reason: 'unreadable' });
     }
     const rolesRead = guarded(() => ({ value: m.roles }));
     const roleEntries = rolesRead === undefined ? undefined : guarded(() => Object.entries(asRec(rolesRead.value) ?? {}));
     if (roleEntries === undefined)
-        drop({ key: 'roles', at: 'models', reason: 'unreadable' });
+        recordDrop({ key: 'roles', at: 'models', reason: 'unreadable' });
     const keptRoles = {};
     for (const [role, t] of roleEntries ?? []) {
         const first = guarded(() => {
@@ -273,20 +354,20 @@ function modelsDocOf(models, opts) {
             return { tr: r, has, model: has ? r.model : undefined };
         });
         if (first === undefined) {
-            drop({ key: 'roles', at: role, reason: 'unreadable' });
+            recordDrop({ key: 'roles', at: role, reason: 'unreadable' });
             continue;
         }
         const { tr, has, model } = first;
         if (typeof model === 'string') {
             const verdict = modelRefVerdict(model);
             if (verdict !== 'accepted') {
-                drop({ key: 'roles', at: role, ...refOf(model), reason: verdict });
+                recordDrop({ key: 'roles', at: role, ...refOf(model), reason: verdict });
                 continue;
             }
         }
         const copy = writtenCopyOf(t, tr !== undefined && has ? { key: 'model', value: model } : undefined);
         if (copy === undefined) {
-            drop({ key: 'roles', at: role, ...refOf(model), reason: 'unreadable' });
+            recordDrop({ key: 'roles', at: role, ...refOf(model), reason: 'unreadable' });
             continue;
         }
         setOwn(keptRoles, role, copy.value);
@@ -301,14 +382,14 @@ function modelsDocOf(models, opts) {
         doc.roles = rolesOut;
     const am = policy.atMention;
     if (am?.kind === 'unreadable') {
-        drop({ key: 'atMention', at: 'atMention', reason: 'unreadable' });
+        recordDrop({ key: 'atMention', at: 'atMention', reason: 'unreadable' });
     }
     else if (am !== undefined) {
         const v = am.value;
         if (v.mode === 'only') {
             for (const n of v.models)
                 if (!names.has(n))
-                    drop({ key: 'atMention', target: n, reason: reasonOf(n) });
+                    recordDrop({ key: 'atMention', target: n, reason: reasonOf(n) });
             const narrowed = SETTINGS_NARROW_AT_MENTION(v, names);
             if (narrowed.mode === 'only') {
                 doc.atMention = { mode: 'only', models: [...narrowed.models] };
@@ -316,7 +397,7 @@ function modelsDocOf(models, opts) {
             else {
                 doc.atMention = { mode: narrowed.mode };
                 if (narrowed.mode === 'none' && !catalogKept)
-                    drop({ key: 'atMention', at: 'atMention', reason: 'dangling' });
+                    recordDrop({ key: 'atMention', at: 'atMention', reason: 'dangling' });
             }
         }
         else if (v.mode === 'none') {
@@ -330,11 +411,11 @@ function modelsDocOf(models, opts) {
         const tgValue = typeof tg === 'object' ? tg.value : undefined;
         const rawGroupNames = new Set((Array.isArray(tgValue) ? tgValue : []).map((g) => asStr(asRec(g)?.name)).filter((n) => !!n));
         if (tg === 'unreadable') {
-            drop({ key: 'tierGroups', at: 'models', reason: 'unreadable' });
+            recordDrop({ key: 'tierGroups', at: 'models', reason: 'unreadable' });
         }
         else if (tg !== 'absent') {
             if (!Array.isArray(tgValue)) {
-                drop({ key: 'tierGroups', reason: 'unreadable' });
+                recordDrop({ key: 'tierGroups', reason: 'unreadable' });
             }
             else {
                 const groups = [];
@@ -343,11 +424,11 @@ function modelsDocOf(models, opts) {
                     const g = asRec(raw);
                     const name = g ? asStr(g.name) : undefined;
                     if (!g || !name || !TIER_GROUP_NAME.test(name)) {
-                        drop({ key: 'tierGroups', ...(name ? { at: name } : {}), reason: 'unreadable' });
+                        recordDrop({ key: 'tierGroups', ...(name ? { at: name } : {}), reason: 'unreadable' });
                         continue;
                     }
                     if (groupNames.has(name)) {
-                        drop({ key: 'tierGroups', at: name, reason: 'duplicate' });
+                        recordDrop({ key: 'tierGroups', at: name, reason: 'duplicate' });
                         continue;
                     }
                     groupNames.add(name);
@@ -355,15 +436,15 @@ function modelsDocOf(models, opts) {
                     if (Object.hasOwn(g, 'tiers')) {
                         const t = asRec(g.tiers);
                         if (!t)
-                            drop({ key: 'tierGroups', at: `${name}.tiers`, reason: 'unreadable' });
+                            recordDrop({ key: 'tierGroups', at: `${name}.tiers`, reason: 'unreadable' });
                         else {
                             for (const [tier, model] of Object.entries(t)) {
                                 if (!TIER_WORDS.includes(tier))
-                                    drop({ key: 'tierGroups', at: `${name}.${tier}`, ...refOf(model), reason: 'unsupported' });
+                                    recordDrop({ key: 'tierGroups', at: `${name}.${tier}`, ...refOf(model), reason: 'unsupported' });
                                 else if (typeof model === 'string' && names.has(model))
                                     setOwn(tiers, tier, model);
                                 else
-                                    drop({ key: 'tierGroups', at: `${name}.${tier}`, ...refOf(model), reason: reasonOf(model) });
+                                    recordDrop({ key: 'tierGroups', at: `${name}.${tier}`, ...refOf(model), reason: reasonOf(model) });
                             }
                         }
                     }
@@ -373,14 +454,14 @@ function modelsDocOf(models, opts) {
             }
         }
         if (atg === 'unreadable') {
-            drop({ key: 'activeTierGroup', at: 'models', reason: 'unreadable' });
+            recordDrop({ key: 'activeTierGroup', at: 'models', reason: 'unreadable' });
         }
         else if (atg !== 'absent') {
             const a = atg.value;
             if (typeof a === 'string' && groupNames?.has(a))
                 doc.activeTierGroup = a;
             else
-                drop({ key: 'activeTierGroup', ...refOf(a), reason: typeof a === 'string' && a !== '' ? (rawGroupNames.has(a) ? 'rejected' : 'dangling') : 'unreadable' });
+                recordDrop({ key: 'activeTierGroup', ...refOf(a), reason: typeof a === 'string' && a !== '' ? (rawGroupNames.has(a) ? 'rejected' : 'dangling') : 'unreadable' });
         }
     }
     return { doc, issues, entriesRead: copied };
@@ -577,14 +658,14 @@ function runtimeCapsOf(b, mode) {
     }
     return { kind: 'configured', caps, uninterpretedKeys: uninterpreted };
 }
-export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts) {
+export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts, skills) {
     const b = asRec(body) ?? {};
     const config = asRec(b.config) ?? {};
     const mcpDomain = asRec(config.mcp);
     const skillsDomain = asRec(config.skills);
     const { specs: mcp, missingEnv: mcpMissing, droppedServers: droppedMcpServers, degradedServers: degradedMcpServers } = cloudMcpToSpecs(mcpDomain?.servers, env);
     const manifest = asArr(skillsDomain?.skills);
-    const skills = cloudSkillsToSpecs(manifest, (hash) => skillBodies[hash] ?? null);
+    const { specs: skillSpecs, dropped: droppedSkills } = projectCloudSkills(manifest, (hash) => skillBodies[hash] ?? null, skills);
     const skillsMissingBody = manifest
         .map((raw) => {
         const s = asRec(raw);
@@ -599,13 +680,14 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
     const view = viewModeOf(b);
     return {
         mcp,
-        skills,
+        skills: skillSpecs,
         modelsDoc,
         modelNames: cloudModelNames(modelsDoc),
         rosterNames: cloudRosterNames(rostersValue),
         missingEnv: [...new Set([...mcpMissing, ...cloudModelMissingKeyEnv(modelsDoc, env)])],
         scope: asStr(b.scope) ?? 'global',
         skillsMissingBody,
+        droppedSkills,
         droppedMcpServers,
         degradedMcpServers,
         droppedModels: entriesRead === undefined ? [] : cloudModelsDropped({ models: entriesRead }),
@@ -688,10 +770,22 @@ const MCP_DROP_SENTENCES = {
         level: 'warn',
         text: (who) => renderMessage(msg('config.mcp.cloudToolAxesInvalid', { who })),
     },
+    'tool-faces-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudToolFacesInvalid', { who })),
+    },
     'elicitation-invalid': {
         level: 'warn',
         text: (who) => renderMessage(msg('config.mcp.cloudElicitationInvalid', { who })),
     },
+    'allow-tools-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudAllowToolsInvalid', { who })),
+    },
+    'entry-unreadable': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudEntryUnreadable', { who })),
+    },
     'name-unusable': {
         level: 'warn',
         text: (who) => renderMessage(msg('config.mcp.cloudNameUnusable', { who })),
@@ -760,13 +854,13 @@ function droppedMcpNotices(carrier) {
             return typeof raw === 'string' && Object.hasOwn(MCP_DROP_SENTENCES, raw) ? raw : undefined;
         });
         const name = guarded(() => readOwnDataNonEmptyString(rowObj, 'name'));
-        const path = reason === 'transport-invalid' ? guarded(() => readOwnDataNonEmptyString(rowObj, 'path')) : undefined;
-        const pathLabel = path !== undefined && /^transport(\.[A-Za-z]{1,32})?$/.test(path) ? ` (${path})` : '';
+        const path = reason === 'transport-invalid' || reason === 'allow-tools-invalid' ? guarded(() => readOwnDataNonEmptyString(rowObj, 'path')) : undefined;
+        const pathLabel = path !== undefined && (reason === 'allow-tools-invalid' ? /^allowTools(\[\d{1,9}\])?$/ : /^transport(\.[A-Za-z]{1,32})?$/).test(path) ? ` (${path})` : '';
         const label = name === undefined
             ? undefined
             : reason === 'name-unusable'
                 ? SETTINGS_DESCRIBE_BAD_WIRE_NAME(name)
-                : reason === 'transport-invalid'
+                : reason === 'transport-invalid' || reason === 'allow-tools-invalid' || reason === 'entry-unreadable'
                     ? `"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${pathLabel}`
                     : `"${name}"${pathLabel}`;
         let bucket = unrecognised;
@@ -854,6 +948,48 @@ function degradedMcpNotices(carrier) {
         return [];
     return [{ level: 'warn', text: renderMessage(msg('config.mcp.cloudTransportDegraded', { who: mcpDropWho(labels, unnamed) })) }];
 }
+function droppedSkillNotices(carrier) {
+    const unreadable = [{ level: 'warn', text: renderMessage(msg('config.skills.cloudDroppedUnreadable')) }];
+    let desc;
+    try {
+        desc = Object.getOwnPropertyDescriptor(carrier, 'droppedSkills');
+    }
+    catch {
+        return unreadable;
+    }
+    if (desc === undefined)
+        return [];
+    if (!Object.hasOwn(desc, 'value'))
+        return unreadable;
+    const rows = desc.value;
+    let count = 0;
+    try {
+        if (!Array.isArray(rows))
+            return unreadable;
+        count = rows.length;
+    }
+    catch {
+        return unreadable;
+    }
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        return unreadable;
+    const labels = [];
+    let unnamed = 0;
+    for (let i = 0; i < count; i++) {
+        const row = guarded(() => readOwnDataValue(rows, String(i)));
+        const rowObj = typeof row === 'object' && row !== null ? row : undefined;
+        const name = guarded(() => readOwnDataNonEmptyString(rowObj, 'name'));
+        if (name === undefined) {
+            unnamed++;
+            continue;
+        }
+        const path = guarded(() => readOwnDataNonEmptyString(rowObj, 'path'));
+        labels.push(`"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${path !== undefined && /^skills\[\d{1,10}\]\.(?:allowedTools|disallowedTools)(?:\[\d{1,10}\])?$/.test(path) ? ` (${path})` : ''}`);
+    }
+    if (labels.length + unnamed === 0)
+        return [];
+    return [{ level: 'warn', text: renderMessage(msg('config.skills.cloudToolListInvalid', { who: mcpDropWho(labels, unnamed) })) }];
+}
 function budgetNotice(r) {
     switch (r.kind) {
         case 'configured': {
@@ -923,6 +1059,7 @@ export function cloudEffectiveNotices(p) {
     }
     out.push(...droppedMcpNotices(p));
     out.push(...degradedMcpNotices(p));
+    out.push(...droppedSkillNotices(p));
     const assertionLine = mcpAssertionHeaderNotSentNotice(guarded(() => readOwnDataValue(p, 'mcp')) ?? []);
     if (assertionLine !== undefined)
         out.push({ level: 'warn', text: `cloud config: ${assertionLine}` });

package/dist/coreValuePorts.d.ts

@@ -16,7 +16,6 @@ export interface AllowDenyPolicyOptionsView {
     deny?: string[];
     onInvalidName?: 'throw' | 'skip';
     onInvalidNameIssue?: (issue: AllowDenyInvalidNameIssueView) => void;
-    scope?: 'grant' | 'narrowing';
 }
 export interface AllowDenyInvalidNameIssueView {
     entry: string;
@@ -118,6 +117,13 @@ export type McpToolAxesReadView = {
     readonly ok: false;
     readonly problem: string;
 };
+export type McpToolFacesReadView = {
+    readonly ok: true;
+    readonly faces?: Readonly<Record<string, object>>;
+} | {
+    readonly ok: false;
+    readonly problem: string;
+};
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
@@ -141,8 +147,10 @@ export interface CoreValuePorts {
     judgeRuleToolName(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView;
     readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView;
     readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView;
+    ANTHROPIC_DEFAULT_BASE_URL: string;
+    readToolFaces(declared: {} | null | undefined): McpToolFacesReadView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -170,3 +178,5 @@ export declare function routePairingStatus(brain: {
 }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;
 export declare function readRuleEntry(raw: {} | null | undefined, behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): RuleEntryReadingView | undefined;
 export declare function readMcpToolAxes(declared: {} | null | undefined): McpToolAxesReadView | undefined;
+export declare function anthropicDefaultBaseUrl(): string | undefined;
+export declare function readToolFaces(declared: {} | null | undefined): McpToolFacesReadView | undefined;

package/dist/coreValuePorts.js

@@ -17,6 +17,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'judgeRuleToolName',
     'readRuleEntry',
     'readMcpToolAxes',
+    'ANTHROPIC_DEFAULT_BASE_URL',
+    'readToolFaces',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -109,3 +111,10 @@ export function readMcpToolAxes(declared) {
     const fn = port('readMcpToolAxes');
     return fn === undefined ? undefined : fn(declared);
 }
+export function anthropicDefaultBaseUrl() {
+    return port('ANTHROPIC_DEFAULT_BASE_URL');
+}
+export function readToolFaces(declared) {
+    const fn = port('readToolFaces');
+    return fn === undefined ? undefined : fn(declared);
+}

package/dist/decideFailureNote.js

@@ -2,7 +2,7 @@ import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError,
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
 import { fieldLimitRefusalContent, fieldLimitRefusalFromError } from './wireRefusalCopy.js';
-import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf } from './hitl/decisionConflict.js';
+import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf, decisionGrantChangedContent } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
@@ -12,7 +12,8 @@ export function decideFailureNote(err, decision) {
     const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
-    const answerInvalid = decisionConflictOf(err) === 'answer_invalid';
+    const conflict = decisionConflictOf(err);
+    const answerInvalid = conflict === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
         (bucket === null ? '' : ` — ${fieldLimitRefusalContent(bucket)}`) +
@@ -21,5 +22,6 @@ export function decideFailureNote(err, decision) {
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
         (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`) +
         (gone === null ? '' : ` — ${askGoneContent(gone)}`) +
-        (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : ''));
+        (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : '') +
+        (conflict === 'grant_changed' ? ` — ${decisionGrantChangedContent()}` : ''));
 }

package/dist/decideReceipt.js

@@ -3,7 +3,7 @@ import { readOwnDataValue } from './ownKey.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
 import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
-import { readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
+import { isSlotCarrier, readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
 import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
 const STATUS_RESUMING = 'resuming';
@@ -166,7 +166,7 @@ function askGoneRawCause(e) {
     return undefined;
 }
 export function askGoneFromError(e) {
-    if (typeof e !== 'object' || e === null)
+    if (!isSlotCarrier(e))
         return null;
     if (effectiveWireErrorCode(e) !== ASK_GONE)
         return null;

package/dist/deviceExecutorManagementCapability.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 { capForDisplay } from './fleetTaskDesc.js';
@@ -44,7 +44,7 @@ const reader = createEngineCapReader({
     name: 'deviceExecutor.management',
     project: projectDeviceExecutorManagementCapability,
 });
-export function observedDeviceExecutorManagement(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedDeviceExecutorManagement(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function deviceManagementVerbsAvailable(reading) {

package/dist/deviceFlowPolling.js

@@ -2,7 +2,7 @@ import { SETTINGS_DEVICE_CODE_TTL_SECONDS, SETTINGS_DEVICE_POLL_INTERVAL_SECONDS
 function positiveSecondsOf(reading, key) {
     try {
         const desc = Object.getOwnPropertyDescriptor(reading, key);
-        if (desc === undefined || !('value' in desc))
+        if (desc === undefined || !Object.hasOwn(desc, 'value'))
             return undefined;
         const v = desc.value;
         return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;

package/dist/disableSkillsWire.d.ts

@@ -1,5 +1,5 @@
 export declare function refuseBadDisableSkills(v: unknown, who: string): void;
-export declare function refuseDisableSkillsConflict(disableSkills: unknown, skills: unknown, agents: unknown, who: string): void;
+export declare function refuseDisableSkillsConflict(disableSkills: unknown, skills: unknown, agents: unknown, who: string, userInvokedSkills?: readonly string[] | null): void;
 type DisableSkillsWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
 export type DisableSkillsDeclaration = {
     readonly field: {

package/dist/disableSkillsWire.js

@@ -17,14 +17,15 @@ export function refuseBadDisableSkills(v, who) {
 }
 const nonEmptyArray = (v) => Array.isArray(v) && v.length > 0;
 const anyAgentCarriesSkills = (agents) => Array.isArray(agents) && agents.some((a) => typeof a === 'object' && a !== null && nonEmptyArray(a.skills));
-export function refuseDisableSkillsConflict(disableSkills, skills, agents, who) {
+export function refuseDisableSkillsConflict(disableSkills, skills, agents, who, userInvokedSkills) {
     if (disableSkills !== true)
         return;
     const inSkills = nonEmptyArray(skills);
     const inAgents = anyAgentCarriesSkills(agents);
-    if (!inSkills && !inAgents)
+    const inNamed = nonEmptyArray(userInvokedSkills);
+    if (!inSkills && !inAgents && !inNamed)
         return;
-    const which = inSkills && inAgents ? 'skills 与 agents[].skills' : inSkills ? 'skills' : 'agents[].skills';
+    const which = [inSkills ? 'skills' : '', inAgents ? 'agents[].skills' : '', inNamed ? 'userInvokedSkills' : ''].filter((x) => x !== '').join(' 与 ');
     throw new TypeError(`${who}: disableSkills: true(这一发一只技能都不装)与非空的 ${which} 同在 —— 二选一:要关技能就别交技能,要交技能就别带 disableSkills。` +
         '上游对这一组合同样拒收(在任何东西跑起来之前);本层在装配前拒,不让它走一次往返。错误文本只报键名,不回显技能名。');
 }