@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/agentsWireCaps.js

@@ -8,6 +8,8 @@ import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
 import { rosterMountedNames } from './rosterMountedNames.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { deniedEntryToolName } from './engineToolDirectory.js';
+import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix } from './coreValuePorts.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { assemblyRefusal, withAssemblyRefusal } from './wireFailureShape.js';
 export const MAX_TASK_AGENTS = 32;
 export const TASK_AGENT_WIRE_FIELDS = [
@@ -28,6 +30,7 @@ export const TASK_AGENT_WIRE_FIELDS = [
     'observerMessage',
 ];
 export const AGENT_MEMORY_WORDS = frozenSet(['user', 'project', 'local']);
+export const REFUSED_PROJECT_SERVER_CAUSES = Object.freeze(['rejected', 'not_approved', 'disabled', 'policy_blocked', 'plugin_only', 'malformed_config']);
 const SOURCE_RANK = {
     policySettings: 0,
     flagSettings: 1,
@@ -113,8 +116,58 @@ function toolListShapeRefusal(agent, key, v) {
     return withAssemblyRefusal(new TypeError(`projectAgentsForWire: agent "${capForDisplay(agent, 80)}" has ${key} written as ${listShapeWord(v)}, but it must be an array of tool-name strings — ` +
         'refusing to assemble the agents list (a list dropped silently would give the agent every tool, or remove a deny rule). Fix the definition.'), 'input_malformed');
 }
+const REFUSED_SERVER_PHRASE_KEYS = Object.freeze({
+    rejected: ['config.agentsWire.refusedServer.cause.rejected', 'config.agentsWire.refusedServer.way.rejected'],
+    not_approved: ['config.agentsWire.refusedServer.cause.notApproved', 'config.agentsWire.refusedServer.way.notApproved'],
+    disabled: ['config.agentsWire.refusedServer.cause.disabled', 'config.agentsWire.refusedServer.way.disabled'],
+    policy_blocked: ['config.agentsWire.refusedServer.cause.policyBlocked', 'config.agentsWire.refusedServer.way.policyBlocked'],
+    plugin_only: ['config.agentsWire.refusedServer.cause.pluginOnly', 'config.agentsWire.refusedServer.way.pluginOnly'],
+    malformed_config: ['config.agentsWire.refusedServer.cause.malformedConfig', 'config.agentsWire.refusedServer.way.malformedConfig'],
+});
+const REFUSED_SERVER_UNKNOWN_PHRASE = ['config.agentsWire.refusedServer.cause.unknown', 'config.agentsWire.refusedServer.way.unknown'];
+const REFUSED_SERVER_NAME_MAX = 80;
+function refusedServerIndexOf(list) {
+    try {
+        if (!Array.isArray(list) || list.length === 0)
+            return [];
+        if (!hasCoreValuePort('protocolOf') || !hasCoreValuePort('mintNamespacePrefix'))
+            return [];
+        const ns = mcpNamespace();
+        if (ns === undefined)
+            return [];
+        const out = [];
+        const seen = new Set();
+        for (const row of list) {
+            try {
+                if (row === null || typeof row !== 'object')
+                    continue;
+                const name = row.name;
+                const cause = row.cause;
+                if (typeof name !== 'string' || name === '' || seen.has(name))
+                    continue;
+                const prefix = mintNamespacePrefix(ns, name);
+                if (typeof prefix !== 'string' || prefix.length === 0)
+                    continue;
+                seen.add(name);
+                const known = typeof cause === 'string' && Object.hasOwn(REFUSED_SERVER_PHRASE_KEYS, cause) ? REFUSED_SERVER_PHRASE_KEYS[cause] : undefined;
+                out.push({ name, prefix, phrase: known ?? REFUSED_SERVER_UNKNOWN_PHRASE });
+            }
+            catch {
+                continue;
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function entryNamesServer(entry, prefix) {
+    return entry.startsWith(prefix) || entry === prefix.slice(0, -2);
+}
 export function projectAgentsForWire(defs, deps) {
     const warnings = [];
+    const refusedServers = refusedServerIndexOf(deps.refusedProjectServers);
     const customs = defs
         .filter(d => d.source !== 'built-in')
         .slice()
@@ -171,9 +224,8 @@ export function projectAgentsForWire(defs, deps) {
             whoMemo = `agent "${name}"${typeof source === 'string' && source.length > 0 ? ` (${capForDisplay(source, 120)})` : ''}`;
             return whoMemo;
         };
-        const rosterInHand = typeof rosterMountedNames(deps.toolRoster) === 'object';
         const flaws = agentToolListFlaws([item], deps.toolRoster).map((f) => {
-            if (!rosterInHand || f.list !== 'disallowedTools' || f.kind !== 'retired' || f.currentName === undefined || f.toolName !== undefined)
+            if (f.list !== 'disallowedTools' || f.kind !== 'retired' || f.currentName === undefined || f.toolName !== undefined)
                 return f;
             const to = f.currentName;
             if (item.denyTools !== undefined)
@@ -191,7 +243,30 @@ export function projectAgentsForWire(defs, deps) {
             for (const f of flaws) {
                 if (f.list !== 'tools')
                     continue;
-                warnings.push(`agents wire: ${who}: its tools entry ${toolListFlawPhrase(f)} — sent as written; tool names are matched exactly, so this entry gives the agent nothing unless this run has a tool with exactly that name. Fix the entry in the agent definition.`);
+                warnings.push(renderMessage(msg('config.agentsWire.toolEntry.sentence', { who, phrase: toolListFlawPhrase(f) })));
+            }
+        }
+        if (refusedServers.length > 0 && item.allowTools !== undefined) {
+            const told = new Set();
+            const mounted = rosterMountedNames(deps.toolRoster);
+            const mountedNames = typeof mounted === 'object' ? mounted : undefined;
+            for (const entry of item.allowTools) {
+                if (mountedNames?.has(entry) === true)
+                    continue;
+                const hit = refusedServers.find((r) => entryNamesServer(entry, r.prefix));
+                if (hit === undefined)
+                    continue;
+                const sentence = renderMessage(msg('config.agentsWire.refusedServer.sentence', {
+                    who: whoOf(),
+                    entry: JSON.stringify(entry),
+                    server: JSON.stringify(capForDisplay(hit.name, REFUSED_SERVER_NAME_MAX)),
+                    cause: msg(hit.phrase[0]),
+                    way: msg(hit.phrase[1]),
+                }));
+                if (told.has(sentence))
+                    continue;
+                told.add(sentence);
+                warnings.push(sentence);
             }
         }
         if (def.memory !== undefined) {
@@ -300,6 +375,12 @@ let preparedKey = null;
 let preparedCapsGen = null;
 let preparedPromise = null;
 let payload;
+function setPayload(agents, warnings) {
+    payload = { agents, warnings: Object.freeze([...warnings]) };
+}
+function clearPayload() {
+    payload = undefined;
+}
 let currentGeneration = null;
 function concludeGeneration(generation, outcome) {
     if (generation !== null && preparedPromise === generation && currentGeneration !== null)
@@ -335,7 +416,7 @@ function watchCapsVerdict(baseUrl) {
     void engineCapsSettled(baseUrl).then(() => {
         if (preparedKey !== baseUrl || capsVerdictAt(baseUrl) !== false)
             return;
-        payload = undefined;
+        clearPayload();
         concludeGeneration(preparedPromise, 'ok');
         currentGeneration?.settle();
     });
@@ -345,12 +426,10 @@ function applyProjectionIfCurrent(generation, projected) {
         return false;
     const accepted = capsVerdictAt(preparedKey) !== false;
     if (accepted) {
-        for (const w of projected.warnings)
-            warnOnce(w);
-        payload = projected.agents;
+        setPayload(projected.agents, projected.warnings);
     }
     else {
-        payload = undefined;
+        clearPayload();
     }
     concludeGeneration(generation, 'ok');
     currentGeneration?.settle();
@@ -361,7 +440,7 @@ async function runPrepare(cfg, projector, generation) {
         const [, projected] = await Promise.all([capsSettledAt(cfg.baseUrl), projector()]);
         if (capsVerdictAt(cfg.baseUrl) === false) {
             if (preparedKey === cfg.baseUrl) {
-                payload = undefined;
+                clearPayload();
                 concludeGeneration(generation, 'ok');
                 if (projected.agents) {
                     warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents is not true: the engine does not report it, or this deployment turns it off, for example a multi-tenant one; this client cannot tell which) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
@@ -371,13 +450,14 @@ async function runPrepare(cfg, projector, generation) {
         }
         if (!applyProjectionIfCurrent(generation, projected))
             return;
-        if (payload && hostEnv().SEMA_DEBUG) {
-            console.error(`[sema] agents wire: ${payload.length} custom agent(s) → TaskRequest.agents (${payload.map(a => a.name).join(', ')})`);
+        const sent = payload?.agents;
+        if (sent && hostEnv().SEMA_DEBUG) {
+            console.error(`[sema] agents wire: ${sent.length} custom agent(s) → TaskRequest.agents (${sent.map(a => a.name).join(', ')})`);
         }
     }
     catch (e) {
         if (preparedPromise === generation)
-            payload = undefined;
+            clearPayload();
         concludeGeneration(generation, 'failed');
         if (hostEnv().SEMA_DEBUG) {
             console.error('[sema] agents wire prepare failed (the readiness gate refuses this turn):', e);
@@ -412,7 +492,7 @@ export function invalidateTaskAgentsWire() {
     const projector = activeProjector;
     if (!preparedPromise || !projector)
         return Promise.resolve();
-    payload = undefined;
+    clearPayload();
     return startGeneration(generation => runReproject(projector, generation));
 }
 async function runReproject(projector, generation) {
@@ -443,7 +523,7 @@ export async function awaitTaskAgentsWire(timeoutMs = 4000) {
         return taskAgentsReady();
     const projector = activeProjector;
     if (currentGeneration?.outcome === 'failed' && projector !== null) {
-        payload = undefined;
+        clearPayload();
         void startGeneration(generation => runReproject(projector, generation));
     }
     let timeoutHandle;
@@ -502,10 +582,14 @@ function kickTaskAgentsRefresh() {
 export function taskAgentsField() {
     const base = preparedKey;
     if (capsVerdictAt(base) === false) {
-        payload = undefined;
+        clearPayload();
         return {};
     }
-    const current = payload;
+    const held = payload;
+    const current = held?.agents;
+    if (held !== undefined)
+        for (const w of held.warnings)
+            warnOnce(w);
     kickTaskAgentsRefresh();
     return current ? { agents: current } : {};
 }
@@ -515,6 +599,6 @@ export function _resetAgentsWireForTest() {
     preparedCapsGen = null;
     preparedPromise = null;
     currentGeneration = null;
-    payload = undefined;
+    clearPayload();
     emittedWarnings.clear();
 }

package/dist/approvalDecidedByCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectApprovalDecidedByCapability(caps) {
@@ -18,7 +18,7 @@ const reader = createEngineCapReader({
     name: 'approvalDecidedBy',
     project: projectApprovalDecidedByCapability,
 });
-export function observedApprovalDecidedBy(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedApprovalDecidedBy(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function approvalDecidedByAdmitted(reading) {

package/dist/approvalFrameFamilies.d.ts

@@ -0,0 +1,33 @@
+export type ApprovalFrameFamiliesReading = {
+    readonly kind: 'confirmed';
+    readonly families: readonly string[];
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function observedApprovalFrameFamilies(baseUrl?: string | undefined): ApprovalFrameFamiliesReading;
+export type ApprovalFrameFamiliesWithheldCause = 'capability_absent' | 'capability_declined' | 'capability_unreadable' | 'reading_absent';
+export interface ApprovalFrameFamiliesWithheld {
+    readonly cause: ApprovalFrameFamiliesWithheldCause;
+}
+export interface ApprovalFrameFamiliesDeclaration {
+    readonly field: {
+        readonly approvalFrameFamilies?: readonly string[];
+    };
+    readonly withheld?: ApprovalFrameFamiliesWithheld;
+}
+export declare function approvalFrameFamiliesDeclaration(reading: ApprovalFrameFamiliesReading): ApprovalFrameFamiliesDeclaration;
+export declare function frameFamiliesJudgementOf(reading: ApprovalFrameFamiliesReading): FrameFamiliesJudgement;
+export type FrameFamiliesJudgement = {
+    readonly ok: true;
+    readonly families: readonly string[];
+} | {
+    readonly ok: false;
+    readonly cause: ApprovalFrameFamiliesWithheldCause;
+};
+export declare function intersectRenderedFamilies(presented: readonly string[], rendered: readonly string[]): readonly string[];

package/dist/approvalFrameFamilies.js

@@ -0,0 +1,120 @@
+import { engineCapNestedValue, engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { appendOwnElement, guardedRead, readOwnDataValue } from './ownKey.js';
+const PRESENTED_FAMILIES_KEY = 'approvalFrameFamilies';
+const ACCEPTANCE_GROUP_KEY = 'taskSettings';
+const ACCEPTANCE_KEY = 'approvalFrameFamilies';
+const SERVER_FRAME_FAMILY_WORDS = Object.freeze(['tool_approval', 'approval_request']);
+const RENDERED_FRAME_FAMILY_WORDS = Object.freeze(['tool_approval', 'approval_request']);
+const MAX_PRESENTED_ENTRIES = 16;
+const READ_ABSENT = Object.freeze({ kind: 'absent' });
+const READ_DECLINED = Object.freeze({ kind: 'declined' });
+const READ_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const READ_UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+function presentedFamiliesOf(raw) {
+    try {
+        if (!Array.isArray(raw)) {
+            if (typeof raw === 'object' && raw !== null)
+                Object.getPrototypeOf(raw);
+            return 'declined';
+        }
+        const lenDesc = Object.getOwnPropertyDescriptor(raw, 'length');
+        const len = lenDesc !== undefined && Object.hasOwn(lenDesc, 'value') ? lenDesc.value : undefined;
+        if (typeof len !== 'number' || !Number.isInteger(len) || len < 0)
+            return 'unreadable';
+        if (len > MAX_PRESENTED_ENTRIES)
+            return 'declined';
+        const out = [];
+        for (let i = 0; i < len; i++) {
+            const d = Object.getOwnPropertyDescriptor(raw, String(i));
+            if (d === undefined)
+                return 'declined';
+            if (!Object.hasOwn(d, 'value'))
+                return 'unreadable';
+            const w = d.value;
+            if (typeof w !== 'string' || !SERVER_FRAME_FAMILY_WORDS.includes(w))
+                return 'declined';
+            if (!out.includes(w))
+                appendOwnElement(out, w);
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function observedApprovalFrameFamilies(baseUrl) {
+    try {
+        const picked = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
+        const base = typeof picked === 'string' ? picked : undefined;
+        const accepted = engineCapNestedValue(base, ACCEPTANCE_GROUP_KEY, ACCEPTANCE_KEY);
+        switch (accepted.kind) {
+            case 'unobserved':
+                return READ_UNOBSERVED;
+            case 'not_reported':
+                return READ_ABSENT;
+            case 'unreadable':
+                return READ_UNREADABLE;
+            case 'null':
+                return READ_DECLINED;
+            case 'value':
+                if (accepted.value !== true)
+                    return READ_DECLINED;
+                break;
+        }
+        const presented = engineCapValue(base, PRESENTED_FAMILIES_KEY);
+        switch (presented.kind) {
+            case 'unobserved':
+                return READ_UNOBSERVED;
+            case 'not_reported':
+                return READ_ABSENT;
+            case 'unreadable':
+                return READ_UNREADABLE;
+            case 'null':
+                return READ_DECLINED;
+            case 'value': {
+                const families = presentedFamiliesOf(presented.value);
+                if (families === 'declined')
+                    return READ_DECLINED;
+                if (families === 'unreadable')
+                    return READ_UNREADABLE;
+                return Object.freeze({ kind: 'confirmed', families });
+            }
+        }
+    }
+    catch {
+        return READ_UNOBSERVED;
+    }
+}
+const NO_FIELD = Object.freeze(Object.create(null));
+function withheldOf(cause) {
+    return Object.freeze({ field: NO_FIELD, withheld: Object.freeze({ cause }) });
+}
+export function approvalFrameFamiliesDeclaration(reading) {
+    const j = judgeReading(reading);
+    return j.ok ? Object.freeze({ field: Object.freeze({ approvalFrameFamilies: j.families }) }) : withheldOf(j.cause);
+}
+export function frameFamiliesJudgementOf(reading) {
+    return judgeReading(reading);
+}
+function judgeReading(reading) {
+    const kind = guardedRead(() => (typeof reading === 'object' && reading !== null ? readOwnDataValue(reading, 'kind') : undefined));
+    if (kind === 'absent')
+        return { ok: false, cause: 'capability_absent' };
+    if (kind === 'declined')
+        return { ok: false, cause: 'capability_declined' };
+    if (kind !== 'confirmed')
+        return { ok: false, cause: 'capability_unreadable' };
+    const raw = guardedRead(() => readOwnDataValue(reading, 'families'));
+    const presented = presentedFamiliesOf(raw);
+    if (presented === 'declined' || presented === 'unreadable')
+        return { ok: false, cause: 'capability_unreadable' };
+    return { ok: true, families: intersectRenderedFamilies(presented, RENDERED_FRAME_FAMILY_WORDS) };
+}
+export function intersectRenderedFamilies(presented, rendered) {
+    const out = [];
+    for (const w of presented)
+        if (rendered.includes(w) && !out.includes(w))
+            appendOwnElement(out, w);
+    return Object.freeze(out);
+}

package/dist/approvalsStreamLiveCapability.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 function projectApprovalsStreamLiveCapability(caps) {
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'approvalsStreamLive',
     project: projectApprovalsStreamLiveCapability,
 });
-export function observedApprovalsStreamLive(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedApprovalsStreamLive(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function livePendingNeedsReconcile(reading) {

package/dist/attachmentsWireCaps.js

@@ -1,6 +1,8 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
 import { retiredAttachmentsKeyOf } from './taskRequestWords.js';
+import { looksLikeKnownSecret, REDACTION_MARKER_PREFIX } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const ATTACHMENTS_ENV = 'SEMA_ATTACHMENTS';
 export const ATTACHMENTS_SPEC_KEYS = Object.freeze([
     'todoReminder',
@@ -57,20 +59,38 @@ function refuse(token, why) {
 function deny(kind, token, why, index, key) {
     return { ok: false, refusal: { kind, token, why, entry: index + 1, key } };
 }
-function judgeAttachmentsEnv(raw) {
+const CREDENTIAL_TOKEN_PLACEHOLDER = `${REDACTION_MARKER_PREFIX}:secret\u00bb`;
+function credentialShapedWord(original) {
+    if (original === undefined || original.length === 0)
+        return false;
+    try {
+        const bare = original.replace(/^[+-]+/, '');
+        const eq = bare.indexOf('=');
+        return looksLikeKnownSecret(original) || looksLikeKnownSecret(bare) || (eq >= 0 && looksLikeKnownSecret(bare.slice(eq + 1)));
+    }
+    catch {
+        return false;
+    }
+}
+function judgeAttachmentsEnv(raw, original = raw) {
     if (envFlagOff(raw))
         return { ok: true, spec: allDefaultOnOff() };
     const tokens = raw.split(',').map(t => t.trim()).filter(t => t.length > 0);
+    const originals = original.split(',').map(t => t.trim()).filter(t => t.length > 0);
+    const denyAt = (kind, token, why, index, key) => deny(kind, credentialShapedWord(originals[index]) ? CREDENTIAL_TOKEN_PLACEHOLDER : token, why, index, key);
     for (const [i, token] of tokens.entries()) {
         const named = retiredAttachmentsKeyOf(token);
         if (named !== undefined)
-            return { ok: false, refusal: { kind: 'retired_key', token, why: named.why, entry: i + 1, key: named.key, retired: named } };
+            return { ok: false, refusal: { kind: 'retired_key', token: credentialShapedWord(originals[i]) ? CREDENTIAL_TOKEN_PLACEHOLDER : token, why: named.why, entry: i + 1, key: named.key, retired: named } };
     }
     if (tokens.length === 0)
         return { ok: true, spec: productDefaultAttachments() };
     if (tokens.length === 1 && (tokens[0] === 'full' || tokens[0] === 'all'))
         return { ok: true, spec: allLiteralTrue() };
     if (tokens.length === 1 && !isKnownToken(tokens[0])) {
+        if (credentialShapedWord(originals[0])) {
+            return deny('credential_shaped_word', CREDENTIAL_TOKEN_PLACEHOLDER, 'the value looks like a credential, not an attachments list', 0, undefined);
+        }
         return { ok: true, spec: productDefaultAttachments() };
     }
     const spec = {};
@@ -86,9 +106,9 @@ function judgeAttachmentsEnv(raw) {
         if (token.startsWith('-')) {
             const key = canonicalKey(token.slice(1));
             if (key === undefined)
-                return deny('unknown_key', token, 'unknown attachments key', i, undefined);
+                return denyAt('unknown_key', token, 'unknown attachments key', i, undefined);
             if (!isDefaultOnKey(key)) {
-                return deny('minus_on_literal_true_key', token, `"${key}" belongs to the literal-true family whose OFF is "delete the key", not "send false" ` +
+                return denyAt('minus_on_literal_true_key', token, `"${key}" belongs to the literal-true family whose OFF is "delete the key", not "send false" ` +
                     '(core wire contract, board [479] ask-2) — simply do not turn it on. ' +
                     `Only the core DEFAULT-ON keys (${ATTACHMENTS_DEFAULT_ON_KEYS.join(' / ')}) accept an explicit false`, i, key);
             }
@@ -98,34 +118,39 @@ function judgeAttachmentsEnv(raw) {
         const [lhs, rhs] = splitAssign(token);
         if (rhs !== undefined) {
             if (canonicalKey(lhs) !== 'todoReminderMode')
-                return deny('value_form_on_other_key', token, 'only `todoReminderMode` takes a `key=value` form', i, canonicalKey(lhs));
+                return denyAt('value_form_on_other_key', token, 'only `todoReminderMode` takes a `key=value` form', i, canonicalKey(lhs));
             const mode = TODO_REMINDER_MODES.find(v => v === rhs);
             if (mode === undefined)
-                return deny('todo_mode_bad_value', token, `todoReminderMode must be one of ${TODO_REMINDER_MODES.join('|')}`, i, 'todoReminderMode');
+                return denyAt('todo_mode_bad_value', token, `todoReminderMode must be one of ${TODO_REMINDER_MODES.join('|')}`, i, 'todoReminderMode');
             spec.todoReminderMode = mode;
             continue;
         }
         const key = canonicalKey(lhs.startsWith('+') ? lhs.slice(1) : lhs);
         if (key === undefined)
-            return deny('unknown_key', token, 'unknown attachments key', i, undefined);
+            return denyAt('unknown_key', token, 'unknown attachments key', i, undefined);
         if (isDefaultOnOnlyKey(key)) {
-            return deny('plus_on_default_on_key', token, `"${key}" is core DEFAULT-ON — turning it "on" is a no-op that would send a redundant true; ` + `use "-${key}" to turn it OFF`, i, key);
+            return denyAt('plus_on_default_on_key', token, `"${key}" is core DEFAULT-ON — turning it "on" is a no-op that would send a redundant true; ` + `use "-${key}" to turn it OFF`, i, key);
         }
         if (key === 'todoReminderMode')
-            return deny('todo_mode_needs_value', token, 'todoReminderMode needs a value: `todoReminderMode=baseline|off`', i, key);
+            return denyAt('todo_mode_needs_value', token, 'todoReminderMode needs a value: `todoReminderMode=baseline|off`', i, key);
         spec[key] = true;
     }
     return { ok: true, spec };
 }
-function envRawOf(env) {
-    return (env[ATTACHMENTS_ENV] ?? '').trim().toLowerCase();
+function envTextOf(env) {
+    const original = (env[ATTACHMENTS_ENV] ?? '').trim();
+    return { lower: original.toLowerCase(), original };
 }
 export function attachmentsForRequest(env = hostEnv()) {
-    const judged = judgeAttachmentsEnv(envRawOf(env));
+    const text = envTextOf(env);
+    const judged = judgeAttachmentsEnv(text.lower, text.original);
     if (!judged.ok)
         return refuse(judged.refusal.token, judged.refusal.why);
     return judged.spec;
 }
+function headWithCatalogLine(head, catalogLine) {
+    return `${head} ${catalogLine} ${attachmentsWayOut()}`;
+}
 function attachmentsWayOut() {
     const on = OPT_IN_KEYS.join(', ');
     const off = ATTACHMENTS_DEFAULT_ON_KEYS.join(', ');
@@ -141,6 +166,8 @@ function attachmentsRefusalSentence(r) {
             return `${head} names "${key}", a key that no longer exists — ${r.retired?.because ?? 'it was retired'}, and a request carrying that key is refused by the server. Remove that entry${r.retired === undefined ? '' : `; ${r.retired.remedy}`}. ${attachmentsWayOut()}`;
         case 'unknown_key':
             return `${head} is not an attachment this version knows. ${attachmentsWayOut()}`;
+        case 'credential_shaped_word':
+            return headWithCatalogLine(head, renderMessage(msg('config.attachments.refusal.credentialShapedWord')));
         case 'minus_on_literal_true_key':
             return key === 'todoReminderMode'
                 ? `${head} puts a minus on todoReminderMode, which is a setting with a value rather than something to turn off — write todoReminderMode=${TODO_REMINDER_MODES.join(' or todoReminderMode=')}, or leave it out of the list. A minus only works on ${ATTACHMENTS_DEFAULT_ON_KEYS.join(', ')}, which are on by default. ${attachmentsWayOut()}`
@@ -160,7 +187,8 @@ function attachmentsUnreadableSentence() {
 }
 export function attachmentsSubmitVerdict(env = hostEnv()) {
     try {
-        const judged = judgeAttachmentsEnv(envRawOf(env));
+        const text = envTextOf(env);
+        const judged = judgeAttachmentsEnv(text.lower, text.original);
         if (judged.ok)
             return { ok: true, attachments: judged.spec };
         return { ok: false, sentence: attachmentsRefusalSentence(judged.refusal), refusedKey: judged.refusal.key };

package/dist/callerCwdCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectCallerCwdCapability(caps) {
@@ -18,7 +18,7 @@ const reader = createEngineCapReader({
     name: 'callerCwd',
     project: projectCallerCwdCapability,
 });
-export function observedCallerCwd(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedCallerCwd(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function callerCwdAdmitted(reading) {

package/dist/centerWiringCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
@@ -95,7 +95,7 @@ const reader = createEngineCapReader({
     name: 'centerWiring',
     project: projectCenterWiringForCache,
 });
-export function observedCenterWiring(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedCenterWiring(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 function guarded(reading) {

package/dist/clockReading.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_CLOCK_READING_MS = 8640000000000000;
+export declare function usableClockMs(t: {} | null | undefined): number | null;

package/dist/clockReading.js

@@ -0,0 +1,4 @@
+export const MAX_CLOCK_READING_MS = 8.64e15;
+export function usableClockMs(t) {
+    return typeof t === 'number' && Number.isFinite(t) && Math.abs(t) <= MAX_CLOCK_READING_MS ? t : null;
+}

package/dist/cloudConfigWireCaps.d.ts

@@ -1,21 +1,39 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import type { McpServerSpec } from './mcpWireCaps.js';
 import type { EnvLike } from './hostEnv.js';
+import type { SkillToolListsReading } from './skillToolListsCapability.js';
+import type { McpEntryKeyIssue } from './generated/settingsSchemaTypes.js';
 export type { McpServerSpec };
 type Rec = Record<string, unknown>;
 export type { EnvLike };
-export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'capped' | 'principal-and-assertion-header' | 'tool-axes-invalid' | 'elicitation-invalid';
+export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'principal-and-assertion-header' | 'tool-axes-invalid' | 'tool-faces-invalid' | 'elicitation-invalid' | 'allow-tools-invalid' | 'entry-unreadable' | 'name-unusable' | 'transport-invalid';
 export interface CloudMcpDroppedServer {
     name?: string;
     reason: CloudMcpDropReason;
+    path?: string;
+    problem?: string;
+}
+export interface CloudMcpDegradedServer {
+    name: string;
+    lost: readonly McpEntryKeyIssue[];
 }
 export interface CloudMcpProjection {
     specs: McpServerSpec[];
     missingEnv: string[];
     droppedServers: CloudMcpDroppedServer[];
+    degradedServers: CloudMcpDegradedServer[];
 }
 export declare function cloudMcpToSpecs(servers: unknown, env: EnvLike): CloudMcpProjection;
-export declare function cloudSkillsToSpecs(manifestSkills: unknown, resolveBody: (contentHash: string) => string | null): SkillSpec[];
+export interface CloudSkillsOptions {
+    readonly skillToolLists?: SkillToolListsReading;
+}
+export type CloudSkillDropReason = 'tool-list-invalid';
+export interface CloudSkillDropped {
+    readonly name: string;
+    readonly reason: CloudSkillDropReason;
+    readonly path: string;
+}
+export declare function cloudSkillsToSpecs(manifestSkills: unknown, resolveBody: (contentHash: string) => string | null, opts?: CloudSkillsOptions): SkillSpec[];
 export interface CloudModelRefIssue {
     readonly key: 'models' | 'roles' | 'atMention' | 'tierGroups' | 'activeTierGroup';
     readonly at?: string;
@@ -110,7 +128,9 @@ export interface CloudProjection {
     missingEnv: string[];
     scope: string;
     skillsMissingBody: string[];
+    droppedSkills: CloudSkillDropped[];
     droppedMcpServers: CloudMcpDroppedServer[];
+    degradedMcpServers: CloudMcpDegradedServer[];
     droppedModels: CloudDroppedModel[];
     execution: CloudExecutionProjection;
     effectiveWarnings: CloudEffectiveWarningsReading;
@@ -118,11 +138,14 @@ export interface CloudProjection {
     runtimeCaps: CloudRuntimeCapsReading;
     modelRefIssues: CloudModelRefIssue[];
 }
-export declare function projectEffectiveBody(body: unknown, skillBodies: Record<string, string>, env: EnvLike, rostersValue?: unknown, opts?: CloudModelsDocOptions): CloudProjection;
+export declare function projectEffectiveBody(body: unknown, skillBodies: Record<string, string>, env: EnvLike, rostersValue?: unknown, opts?: CloudModelsDocOptions, skills?: CloudSkillsOptions): CloudProjection;
 export interface CloudEffectiveNotice {
     readonly level: 'warn' | 'info';
     readonly text: string;
 }
-export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues' | 'droppedMcpServers'> & {
+export interface CloudEffectiveNoticesOptionalInput {
     readonly mcp?: readonly McpServerSpec[];
-}): CloudEffectiveNotice[];
+    readonly degradedMcpServers?: readonly CloudMcpDegradedServer[];
+    readonly droppedSkills?: readonly CloudSkillDropped[];
+}
+export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues' | 'droppedMcpServers'> & CloudEffectiveNoticesOptionalInput): CloudEffectiveNotice[];