@sema-agent/client-core 0.99.0 → 0.100.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()
@@ -191,7 +244,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 +376,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 +417,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 +427,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 +441,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 +451,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 +493,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 +524,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 +583,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 +600,6 @@ export function _resetAgentsWireForTest() {
     preparedCapsGen = null;
     preparedPromise = null;
     currentGeneration = null;
-    payload = undefined;
+    clearPayload();
     emittedWarnings.clear();
 }

package/dist/cloudConfigWireCaps.d.ts

@@ -1,18 +1,25 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import type { McpServerSpec } from './mcpWireCaps.js';
 import type { EnvLike } from './hostEnv.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' | 'elicitation-invalid' | 'name-unusable' | 'transport-invalid';
 export interface CloudMcpDroppedServer {
     name?: string;
     reason: CloudMcpDropReason;
+    path?: 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[];
@@ -111,6 +118,7 @@ export interface CloudProjection {
     scope: string;
     skillsMissingBody: string[];
     droppedMcpServers: CloudMcpDroppedServer[];
+    degradedMcpServers: CloudMcpDegradedServer[];
     droppedModels: CloudDroppedModel[];
     execution: CloudExecutionProjection;
     effectiveWarnings: CloudEffectiveWarningsReading;
@@ -125,4 +133,5 @@ export interface CloudEffectiveNotice {
 }
 export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues' | 'droppedMcpServers'> & {
     readonly mcp?: readonly McpServerSpec[];
+    readonly degradedMcpServers?: readonly CloudMcpDegradedServer[];
 }): CloudEffectiveNotice[];

package/dist/cloudConfigWireCaps.js

@@ -1,11 +1,14 @@
-import { MCP_CAPS, mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
+import { mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
 import { 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';
 import { TIER_ORDER } from './model/tierVocabulary.js';
 import { SETTINGS_NARROW_AT_MENTION } from './generated/settingsSchemaFns.js';
 import { modelsPolicyOf } from './model/modelsPolicy.js';
 import { normalizeEngineBaseUrl } from './engineUrl.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 import { SETTINGS_BUDGET_NUMBER_KEYS, SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS, SETTINGS_BUDGET_STRING_KEYS, SETTINGS_TIER_GROUP_NAME_RE, } from './generated/settingsSchemaTables.js';
 const asRec = (v) => (typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined);
 const asArr = (v) => (Array.isArray(v) ? v : []);
@@ -14,16 +17,13 @@ export function cloudMcpToSpecs(servers, env) {
     const specs = [];
     const missingEnv = [];
     const droppedServers = [];
-    const drop = (name, reason) => {
-        droppedServers.push({ ...(name ? { name } : {}), reason });
+    const degradedServers = [];
+    const drop = (name, reason, path) => {
+        droppedServers.push({ ...(name ? { name } : {}), reason, ...(path !== undefined ? { path } : {}) });
     };
     for (const raw of asArr(servers)) {
         const s = asRec(raw);
         const name = s ? asStr(s.name) : undefined;
-        if (specs.length >= MCP_CAPS.items) {
-            drop(name, 'capped');
-            continue;
-        }
         if (!s || s.enabled === false) {
             drop(name, s?.enabled === false ? 'disabled' : 'missing-field');
             continue;
@@ -33,66 +33,79 @@ export function cloudMcpToSpecs(servers, env) {
             drop(name, 'missing-field');
             continue;
         }
-        let transport = null;
-        if (t.kind === 'stdio') {
-            const command = asStr(t.command);
-            if (!command) {
-                drop(name, 'missing-field');
-                continue;
-            }
-            const envOut = {};
-            for (const [target, ref] of Object.entries(asRec(t.envRefs) ?? {})) {
+        if (!SETTINGS_IS_USABLE_WIRE_NAME(name)) {
+            drop(name, 'name-unusable');
+            continue;
+        }
+        let candidate;
+        let requiredRaw;
+        const missingHere = [];
+        const resolveRefs = (refs) => {
+            const out = [];
+            for (const [target, ref] of Object.entries(asRec(refs) ?? {})) {
                 const refName = asStr(ref);
                 if (!refName)
                     continue;
                 const v = env[refName];
                 if (v === undefined || v === '')
-                    missingEnv.push(refName);
+                    missingHere.push(refName);
                 else
-                    envOut[target] = v;
+                    out.push([target, v]);
             }
-            const args = asArr(t.args).filter((a) => typeof a === 'string');
-            transport = {
-                kind: 'stdio',
-                command,
-                ...(args.length > 0 ? { args } : {}),
-                ...(Object.keys(envOut).length > 0 ? { env: envOut } : {}),
-            };
-        }
-        else if (t.kind === 'http') {
-            const url = asStr(t.url);
-            if (!url) {
+            return out;
+        };
+        const dropHard = (issue, raw) => {
+            const missing = (issue.path === 'transport.command' || issue.path === 'transport.url') && asStr(raw) === undefined;
+            if (missing)
                 drop(name, 'missing-field');
-                continue;
-            }
-            const identity = readMcpHttpIdentityHeaders(t);
-            if (identity.kind === 'both_set') {
-                drop(name, 'principal-and-assertion-header');
-                continue;
+            else
+                drop(name, 'transport-invalid', issue.path);
+        };
+        try {
+            if (t.kind === 'stdio') {
+                const command = t.command;
+                requiredRaw = command;
+                const head = SETTINGS_READ_REQUEST_MCP_TRANSPORT({ kind: 'stdio', command });
+                if (!head.ok) {
+                    dropHard(head.issue, command);
+                    continue;
+                }
+                const envEntries = resolveRefs(t.envRefs);
+                candidate = { kind: 'stdio', command, args: snapshotArgs(t.args), env: envEntries.length > 0 ? Object.fromEntries(envEntries) : undefined };
             }
-            const headers = {};
-            for (const [headerName, ref] of Object.entries(asRec(t.headerRefs) ?? {})) {
-                const refName = asStr(ref);
-                if (!refName)
+            else if (t.kind === 'http') {
+                const url = t.url;
+                requiredRaw = url;
+                const head = SETTINGS_READ_REQUEST_MCP_TRANSPORT({ kind: 'http', url });
+                if (!head.ok) {
+                    dropHard(head.issue, url);
                     continue;
-                const v = env[refName];
-                if (v === undefined || v === '')
-                    missingEnv.push(refName);
-                else
-                    headers[headerName] = v;
+                }
+                const principalHeader = t.principalHeader;
+                const assertionHeader = t.assertionHeader;
+                if (readMcpHttpIdentityHeaders({ principalHeader, assertionHeader }).kind === 'both_set') {
+                    drop(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');
+                continue;
             }
-            transport = {
-                kind: 'http',
-                url,
-                ...(Object.keys(headers).length > 0 ? { headers } : {}),
-                ...(identity.principalHeader !== undefined ? { principalHeader: identity.principalHeader } : {}),
-                ...(identity.assertionHeader !== undefined ? { assertionHeader: identity.assertionHeader } : {}),
-            };
         }
-        else {
-            drop(name, 'unknown-transport');
+        catch {
+            drop(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;
         const axesVerdict = mcpToolAxesVerdict(axesDeclared);
         if (axesVerdict.kind === 'bad') {
@@ -107,6 +120,8 @@ export function cloudMcpToSpecs(servers, env) {
         }
         const allowToolsWritten = Array.isArray(s.allowTools);
         const allowTools = asArr(s.allowTools).filter((a) => typeof a === 'string');
+        if (read.lost.length > 0)
+            degradedServers.push({ name, lost: Object.freeze([...read.lost]) });
         specs.push({
             name,
             transport,
@@ -116,7 +131,7 @@ export function cloudMcpToSpecs(servers, env) {
             ...(axesShipped !== undefined ? { toolAxes: axesShipped } : {}),
         });
     }
-    return { specs, missingEnv: [...new Set(missingEnv)], droppedServers };
+    return { specs, missingEnv: [...new Set(missingEnv)], droppedServers, degradedServers };
 }
 export function cloudSkillsToSpecs(manifestSkills, resolveBody) {
     const specs = [];
@@ -567,7 +582,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
     const config = asRec(b.config) ?? {};
     const mcpDomain = asRec(config.mcp);
     const skillsDomain = asRec(config.skills);
-    const { specs: mcp, missingEnv: mcpMissing, droppedServers: droppedMcpServers } = cloudMcpToSpecs(mcpDomain?.servers, env);
+    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 skillsMissingBody = manifest
@@ -592,6 +607,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
         scope: asStr(b.scope) ?? 'global',
         skillsMissingBody,
         droppedMcpServers,
+        degradedMcpServers,
         droppedModels: entriesRead === undefined ? [] : cloudModelsDropped({ models: entriesRead }),
         execution: cloudExecutionToPolicy(config.execution),
         effectiveWarnings: effectiveWarningsOf(b),
@@ -676,9 +692,13 @@ const MCP_DROP_SENTENCES = {
         level: 'warn',
         text: (who) => renderMessage(msg('config.mcp.cloudElicitationInvalid', { who })),
     },
-    capped: {
+    'name-unusable': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudNameUnusable', { who })),
+    },
+    'transport-invalid': {
         level: 'warn',
-        text: (who) => `cloud config: MCP server entries left out because more than ${MCP_CAPS.items} were served to you and this client passes at most ${MCP_CAPS.items} to the engine: ${who}`,
+        text: (who) => renderMessage(msg('config.mcp.cloudTransportInvalid', { who })),
     },
     disabled: {
         level: 'info',
@@ -688,9 +708,9 @@ const MCP_DROP_SENTENCES = {
 const MCP_DROP_UNRECOGNISED = (who) => `cloud config: MCP server entries left out for a reason this client does not recognise: ${who}`;
 const MCP_DROP_LIST_UNREADABLE = 'cloud config: the list of MCP server entries left out could not be read by this client — servers missing from the local tool list may have been left out without notice';
 const MCP_DROP_NAMES_SHOWN = 5;
-function mcpDropWho(names, unnamed) {
-    const distinct = [...new Set(names)];
-    const parts = distinct.slice(0, MCP_DROP_NAMES_SHOWN).map((n) => `"${n}"`);
+function mcpDropWho(labels, unnamed) {
+    const distinct = [...new Set(labels)];
+    const parts = distinct.slice(0, MCP_DROP_NAMES_SHOWN);
     if (distinct.length > MCP_DROP_NAMES_SHOWN)
         parts.push(`+${distinct.length - MCP_DROP_NAMES_SHOWN} more`);
     if (unnamed > 0)
@@ -728,6 +748,8 @@ function droppedMcpNotices(carrier) {
     catch {
         return listUnreadable;
     }
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        return listUnreadable;
     const known = new Map();
     const unrecognised = { names: [], unnamed: 0 };
     for (let i = 0; i < count; i++) {
@@ -738,6 +760,15 @@ 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 label = name === undefined
+            ? undefined
+            : reason === 'name-unusable'
+                ? SETTINGS_DESCRIBE_BAD_WIRE_NAME(name)
+                : reason === 'transport-invalid'
+                    ? `"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${pathLabel}`
+                    : `"${name}"${pathLabel}`;
         let bucket = unrecognised;
         if (reason !== undefined) {
             let b = known.get(reason);
@@ -745,10 +776,10 @@ function droppedMcpNotices(carrier) {
                 known.set(reason, (b = { names: [], unnamed: 0 }));
             bucket = b;
         }
-        if (name === undefined)
+        if (label === undefined)
             bucket.unnamed++;
         else
-            bucket.names.push(name);
+            bucket.names.push(label);
     }
     const out = [];
     for (const reason of Object.keys(MCP_DROP_SENTENCES)) {
@@ -761,6 +792,68 @@ function droppedMcpNotices(carrier) {
     }
     return out;
 }
+const DEGRADED_LOST_SHOWN = 80;
+const DEGRADED_NAME_SHOWN = 128;
+const LOST_PATH_SHAPE = /^transport(\.[A-Za-z_][A-Za-z0-9_]{0,31}){1,2}$/;
+function degradedLostLabels(rowObj) {
+    const lost = readOwnDataValue(rowObj, 'lost');
+    const out = [];
+    if (!Array.isArray(lost))
+        return out;
+    const n = guarded(() => lost.length) ?? 0;
+    for (let i = 0; i < n; i++) {
+        const one = guarded(() => readOwnDataValue(lost, String(i)));
+        const issue = typeof one === 'object' && one !== null ? one : undefined;
+        const path = guarded(() => readOwnDataNonEmptyString(issue, 'path'));
+        if (path === undefined || !LOST_PATH_SHAPE.test(path))
+            continue;
+        const member = guarded(() => readOwnDataNonEmptyString(issue, 'member'));
+        out.push(member !== undefined && !path.endsWith(`.${member}`) ? `${path} (member "${capForDisplay(member, DEGRADED_LOST_SHOWN)}")` : path);
+    }
+    return [...new Set(out)];
+}
+function degradedMcpNotices(carrier) {
+    const unreadable = [{ level: 'warn', text: renderMessage(msg('config.mcp.cloudTransportDegradedUnreadable')) }];
+    let desc;
+    try {
+        desc = Object.getOwnPropertyDescriptor(carrier, 'degradedMcpServers');
+    }
+    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 paths = guarded(() => degradedLostLabels(rowObj)) ?? [];
+        labels.push(`"${capForDisplay(name, DEGRADED_NAME_SHOWN)}"${paths.length > 0 ? ` (${paths.join(', ')})` : ''}`);
+    }
+    if (labels.length + unnamed === 0)
+        return [];
+    return [{ level: 'warn', text: renderMessage(msg('config.mcp.cloudTransportDegraded', { who: mcpDropWho(labels, unnamed) })) }];
+}
 function budgetNotice(r) {
     switch (r.kind) {
         case 'configured': {
@@ -829,6 +922,7 @@ export function cloudEffectiveNotices(p) {
         });
     }
     out.push(...droppedMcpNotices(p));
+    out.push(...degradedMcpNotices(p));
     const assertionLine = mcpAssertionHeaderNotSentNotice(guarded(() => readOwnDataValue(p, 'mcp')) ?? []);
     if (assertionLine !== undefined)
         out.push({ level: 'warn', text: `cloud config: ${assertionLine}` });

package/dist/compactionStatus.d.ts

@@ -0,0 +1,34 @@
+export interface CompactionStatusReading {
+    readonly compacting: boolean;
+    readonly since?: number;
+}
+export type CompactionStatusChange = {
+    readonly kind: 'opened';
+    readonly pass: string;
+    readonly since?: number;
+} | {
+    readonly kind: 'closed';
+    readonly pass: string;
+    readonly result?: 'success' | 'failed';
+    readonly error?: string;
+};
+export interface CompactionStatusTracker {
+    take(input: {} | null | undefined): CompactionStatusChange | null;
+    streamEnded(): CompactionStatusChange | null;
+    reading(): CompactionStatusReading;
+}
+export interface PrintCompactionStatusFrame {
+    readonly type: 'system';
+    readonly subtype: 'status';
+    readonly status: 'compacting' | null;
+    readonly compact_result?: 'success' | 'failed';
+    readonly compact_error?: string;
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export interface PrintCompactionStatusCtx {
+    readonly sessionId: string;
+    readonly mintUuid: () => string;
+}
+export declare function createCompactionStatusTracker(): CompactionStatusTracker;
+export declare function compactionStatusFrameOf(change: CompactionStatusChange | null | undefined, ctx: PrintCompactionStatusCtx): PrintCompactionStatusFrame | null;