@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/assistantInbox.js

@@ -0,0 +1,118 @@
+import { errCodes } from './controlRouter.js';
+import { readOwnDataValue } from './ownKey.js';
+import { isReadCredentialRefusal } from './readCredentialRefusal.js';
+import { wireFailureShapeOf } from './wireFailureShape.js';
+export function isAssistantLaneAbsent(err) {
+    try {
+        return errCodes(err).status === 501;
+    }
+    catch {
+        return false;
+    }
+}
+const SEVERITIES = new Set([1, 2, 3, 4, 5]);
+function own(v, key) {
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function nonEmptyString(v) {
+    return typeof v === 'string' && v !== '' ? v : undefined;
+}
+function finiteNonNeg(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
+}
+function entryOf(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return null;
+    const sessionId = nonEmptyString(own(raw, 'sessionId'));
+    if (sessionId === undefined)
+        return null;
+    const scope = nonEmptyString(own(raw, 'scope'));
+    const gateKind = nonEmptyString(own(raw, 'gateKind'));
+    const sev = own(raw, 'severity');
+    const severity = typeof sev === 'number' && SEVERITIES.has(sev) ? sev : undefined;
+    const spent = finiteNonNeg(own(raw, 'spentMicroUsd'));
+    const deadline = finiteNonNeg(own(raw, 'deadline'));
+    const created = finiteNonNeg(own(raw, 'createdAt'));
+    const objective = nonEmptyString(own(raw, 'objective'));
+    const input = own(raw, 'input');
+    const inputPreview = typeof input === 'string' && input !== '' ? input : undefined;
+    return Object.freeze({
+        sessionId,
+        ...(scope !== undefined ? { scope } : {}),
+        ...(gateKind !== undefined ? { gateKind } : {}),
+        ...(severity !== undefined ? { severity } : {}),
+        ...(spent !== undefined ? { spentMicroUsd: spent } : {}),
+        ...(deadline !== undefined ? { deadlineMs: deadline } : {}),
+        ...(created !== undefined ? { createdAtMs: created } : {}),
+        ...(objective !== undefined ? { objective } : {}),
+        ...(inputPreview !== undefined ? { inputPreview } : {}),
+        ...(own(raw, 'requiresRealApproval') === true ? { requiresRealApproval: true } : {}),
+        ...(own(raw, 'mandated') === true ? { mandated: true } : {}),
+        ...(own(raw, 'hasBidiControls') === true ? { hasBidiControls: true } : {}),
+    });
+}
+function isArraySafely(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function unavailable(reason, e) {
+    if (e === undefined)
+        return Object.freeze({ kind: 'unavailable', reason });
+    const { status, errorCode } = wireFailureShapeOf(e);
+    return Object.freeze({
+        kind: 'unavailable',
+        reason,
+        ...(status !== undefined ? { status } : {}),
+        ...(errorCode !== undefined && errorCode !== '' ? { errorCode } : {}),
+    });
+}
+export async function readAssistantInbox(assistant, opts) {
+    let verb;
+    let signal;
+    try {
+        verb = assistant === null || assistant === undefined ? undefined : Reflect.get(assistant, 'inbox');
+        const s = opts === undefined ? undefined : opts.signal;
+        if (s !== undefined && s !== null)
+            signal = s;
+    }
+    catch {
+        return Object.freeze({ kind: 'not-reported', via: 'unarmed' });
+    }
+    if (typeof verb !== 'function')
+        return Object.freeze({ kind: 'not-reported', via: 'unarmed' });
+    let body;
+    try {
+        body = await verb.call(assistant, signal !== undefined ? { signal } : undefined);
+    }
+    catch (e) {
+        if (isAssistantLaneAbsent(e))
+            return Object.freeze({ kind: 'not-reported', via: 'lane-absent' });
+        return unavailable(isReadCredentialRefusal(e) ? 'unauthorized' : 'failed', e);
+    }
+    const raw = body !== null && typeof body === 'object' ? own(body, 'inbox') : undefined;
+    if (!isArraySafely(raw))
+        return unavailable('unreadable');
+    const entries = [];
+    let dropped = 0;
+    const lenRaw = own(raw, 'length');
+    if (typeof lenRaw !== 'number' || !Number.isInteger(lenRaw) || lenRaw < 0)
+        return unavailable('unreadable');
+    const len = lenRaw;
+    for (let i = 0; i < len; i++) {
+        const e = entryOf(own(raw, String(i)));
+        if (e === null)
+            dropped++;
+        else
+            entries.push(e);
+    }
+    return Object.freeze({ kind: 'present', entries: Object.freeze(entries), dropped });
+}

package/dist/centerWiringCapability.js

@@ -83,9 +83,17 @@ function projectCenterWiringOf(caps) {
         },
     };
 }
+function projectCenterWiringForCache(caps) {
+    const r = projectCenterWiringCapability(caps);
+    if (r === undefined || r.kind !== 'present' || r.view.caller === undefined)
+        return r;
+    const view = { ...r.view };
+    delete view.caller;
+    return { kind: 'present', view };
+}
 const reader = createEngineCapReader({
     name: 'centerWiring',
-    project: projectCenterWiringCapability,
+    project: projectCenterWiringForCache,
 });
 export function observedCenterWiring(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);

package/dist/clientSlice.d.ts

@@ -35,10 +35,6 @@ export interface ClientSliceLike {
     }): Promise<unknown>;
     readSession(sessionId: string): Promise<unknown>;
     capabilities(): Promise<unknown>;
-    probeHealth(): Promise<{
-        ok: boolean;
-        version?: string;
-    }>;
 }
 export declare const CLIENT_VERBS: readonly [{
     readonly verb: "streamTask";
@@ -88,14 +84,9 @@ export declare const CLIENT_VERBS: readonly [{
     readonly verb: "capabilities";
     readonly required: true;
     readonly duty: "引擎 caps(所有能力门的数据源;不实现 = 门全判假)";
-}, {
-    readonly verb: "probeHealth";
-    readonly required: false;
-    readonly duty: "健康探测";
 }];
 type _MissingFromTable = Exclude<keyof ClientSliceLike, (typeof CLIENT_VERBS)[number]['verb']>;
 type _ExtraInTable = Exclude<(typeof CLIENT_VERBS)[number]['verb'], keyof ClientSliceLike>;
 type _MustBeNever<T extends never> = T;
 export type _VerbTableClosure = [_MustBeNever<_MissingFromTable>, _MustBeNever<_ExtraInTable>];
-export declare const PROBE_HEALTH_DIVERGENCE: string;
 export {};

package/dist/clientSlice.js

@@ -11,7 +11,4 @@ export const CLIENT_VERBS = [
     { verb: 'listSessions', required: false, duty: 'resume 选单' },
     { verb: 'readSession', required: false, duty: '读历史转录' },
     { verb: 'capabilities', required: true, duty: '引擎 caps(所有能力门的数据源;不实现 = 门全判假)' },
-    { verb: 'probeHealth', required: false, duty: '健康探测' },
 ];
-export const PROBE_HEALTH_DIVERGENCE = 'probeHealth: SDK 要求 status==="ok",壳侧 limitsWire:225 / detachWire:82 手拼只要 res.ok。' +
-    'B4 保旧行为(res.ok),差异待定 —— 换成 SDK 语义会让"自报 degraded 但可用"的引擎少发 detach 头。';

package/dist/cloudConfigWireCaps.d.ts

@@ -4,7 +4,7 @@ import type { EnvLike } from './hostEnv.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';
+export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'capped' | 'principal-and-assertion-header' | 'tool-axes-invalid' | 'elicitation-invalid';
 export interface CloudMcpDroppedServer {
     name?: string;
     reason: CloudMcpDropReason;
@@ -20,7 +20,7 @@ export interface CloudModelRefIssue {
     readonly key: 'models' | 'roles' | 'atMention' | 'tierGroups' | 'activeTierGroup';
     readonly at?: string;
     readonly target?: string;
-    readonly reason: 'dangling' | 'rejected' | 'unreadable' | 'unsupported' | 'duplicate' | 'shadowed' | 'unvouched';
+    readonly reason: 'dangling' | 'rejected' | 'unreadable' | 'unsupported' | 'duplicate' | 'unvouched';
     readonly outcome: 'dropped' | 'kept';
 }
 export interface CloudModelsDocOptions {
@@ -123,4 +123,6 @@ export interface CloudEffectiveNotice {
     readonly level: 'warn' | 'info';
     readonly text: string;
 }
-export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues' | 'droppedMcpServers'>): CloudEffectiveNotice[];
+export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues' | 'droppedMcpServers'> & {
+    readonly mcp?: readonly McpServerSpec[];
+}): CloudEffectiveNotice[];

package/dist/cloudConfigWireCaps.js

@@ -1,8 +1,10 @@
-import { MCP_CAPS } from './mcpWireCaps.js';
+import { MCP_CAPS, mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
 import { toCappedSpec } from './skillsWireCaps.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 { 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);
@@ -63,7 +65,8 @@ export function cloudMcpToSpecs(servers, env) {
                 drop(name, 'missing-field');
                 continue;
             }
-            if (asStr(t.principalHeader) && asStr(t.assertionHeader)) {
+            const identity = readMcpHttpIdentityHeaders(t);
+            if (identity.kind === 'both_set') {
                 drop(name, 'principal-and-assertion-header');
                 continue;
             }
@@ -78,26 +81,39 @@ export function cloudMcpToSpecs(servers, env) {
                 else
                     headers[headerName] = v;
             }
-            const principalHeader = asStr(t.principalHeader);
             transport = {
                 kind: 'http',
                 url,
                 ...(Object.keys(headers).length > 0 ? { headers } : {}),
-                ...(principalHeader ? { principalHeader } : {}),
+                ...(identity.principalHeader !== undefined ? { principalHeader: identity.principalHeader } : {}),
+                ...(identity.assertionHeader !== undefined ? { assertionHeader: identity.assertionHeader } : {}),
             };
         }
         else {
             drop(name, 'unknown-transport');
             continue;
         }
+        const axesDeclared = s.toolAxes;
+        const axesVerdict = mcpToolAxesVerdict(axesDeclared);
+        if (axesVerdict.kind === 'bad') {
+            drop(name, 'tool-axes-invalid');
+            continue;
+        }
+        const axesShipped = axesVerdict.kind === 'ok' ? axesVerdict.toolAxes : axesDeclared;
+        const elVerdict = mcpElicitationVerdict(s.elicitation);
+        if (elVerdict.kind === 'bad') {
+            drop(name, 'elicitation-invalid');
+            continue;
+        }
+        const allowToolsWritten = Array.isArray(s.allowTools);
         const allowTools = asArr(s.allowTools).filter((a) => typeof a === 'string');
         specs.push({
             name,
             transport,
-            ...(allowTools.length > 0 ? { allowTools } : {}),
-            ...(s.elicitation === true ? { elicitation: true } : {}),
+            ...(allowToolsWritten ? { allowTools } : {}),
+            ...(elVerdict.elicitation !== undefined ? { elicitation: elVerdict.elicitation } : {}),
             ...(s.toolFaces !== undefined ? { toolFaces: s.toolFaces } : {}),
-            ...(s.toolAxes !== undefined ? { toolAxes: s.toolAxes } : {}),
+            ...(axesShipped !== undefined ? { toolAxes: axesShipped } : {}),
         });
     }
     return { specs, missingEnv: [...new Set(missingEnv)], droppedServers };
@@ -145,17 +161,54 @@ const setOwn = (o, k, v) => {
 function modelsDocPositionOf(m, key) {
     return guardedRead(() => (Object.hasOwn(m, key) ? { value: m[key] } : 'absent')) ?? 'unreadable';
 }
+function writtenCopyOf(v, pinned) {
+    try {
+        if (pinned === undefined) {
+            const enc = JSON.stringify(v);
+            return enc === undefined ? undefined : { value: JSON.parse(enc) };
+        }
+        const src = asRec(v);
+        if (src === undefined)
+            return undefined;
+        const out = {};
+        for (const k of Object.keys(src)) {
+            const enc = JSON.stringify(k === pinned.key ? pinned.value : src[k]);
+            if (enc !== undefined)
+                setOwn(out, k, JSON.parse(enc));
+        }
+        return { value: out };
+    }
+    catch {
+        return undefined;
+    }
+}
 function modelsDocOf(models, opts) {
     const m = asRec(models);
-    if (!m || !Array.isArray(m.models))
+    const rawModels = m === undefined ? undefined : guarded(() => m.models);
+    if (!m || !Array.isArray(rawModels))
         return { doc: null, issues: [] };
-    const entries = m.models.filter((e) => {
+    const copyFailures = [];
+    const copied = [];
+    for (const raw of rawModels) {
+        const c = writtenCopyOf(raw);
+        if (c !== undefined) {
+            copied.push(c.value);
+            continue;
+        }
+        const nm = guarded(() => asStr(asRec(raw)?.name));
+        if (nm !== undefined)
+            copyFailures.push({ key: 'models', target: nm, reason: 'rejected', outcome: 'dropped' });
+    }
+    if (copied.length === 0 && copyFailures.length > 0) {
+        throw new Error('cloud config: no model entry served to you could be read as data, so the models setting cannot be written; the previous one is kept');
+    }
+    const entries = copied.filter((e) => {
         const r = asRec(e);
         return !!r && !!asStr(r.name) && !!asStr(r.id);
     });
     const stripped = entries.map(withoutRegistryAnnotations);
     const allNames = new Set(entries.map((e) => e.name));
-    const rawNames = new Set(m.models.map((e) => asStr(asRec(e)?.name)).filter((n) => !!n));
+    const rawNames = new Set([...copied.map((e) => asStr(asRec(e)?.name)), ...copyFailures.map((i) => i.target)].filter((n) => !!n));
     const accept = typeof opts?.entryAccepted === 'function' ? opts.entryAccepted : undefined;
     const acceptedName = (e) => {
         try {
@@ -168,7 +221,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 = [];
+    const issues = [...copyFailures];
     const drop = (i) => {
         issues.push({ ...i, outcome: 'dropped' });
     };
@@ -193,49 +246,22 @@ function modelsDocOf(models, opts) {
         drop({ key: 'roles', at: 'default', reason: 'unreadable' });
         drop({ key: 'atMention', at: 'models', reason: 'unreadable' });
     }
-    if (policy.defaultUnreadable)
-        drop({ key: 'roles', at: 'default', reason: 'unreadable' });
-    const dm = policy.defaultModel;
-    let defaultRole;
-    let defaultWinner;
-    if (dm !== undefined && dm.from === 'default') {
-        const verdict = modelRefVerdict(dm.name);
-        if (verdict === 'accepted')
-            defaultRole = { model: dm.name };
-        else
-            drop({ key: 'roles', at: 'default', target: dm.name, reason: verdict });
-        if (verdict === 'accepted' || verdict === 'unvouched')
-            defaultWinner = dm.name;
-    }
-    const roles = asRec(m.roles);
+    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' });
     const keptRoles = {};
-    let sameModelDefaultRole;
-    for (const [role, t] of Object.entries(roles ?? {})) {
-        if (role === 'default' && defaultWinner !== undefined) {
-            const tr = asRec(t);
-            let model;
-            let snapshot;
-            try {
-                model = tr && Object.hasOwn(tr, 'model') ? tr.model : undefined;
-                if (tr !== undefined && typeof model === 'string' && model === defaultWinner) {
-                    snapshot = {};
-                    for (const [k, v] of Object.entries(tr))
-                        setOwn(snapshot, k, v);
-                    setOwn(snapshot, 'model', model);
-                }
-            }
-            catch {
-                model = undefined;
-                snapshot = undefined;
-            }
-            if (snapshot !== undefined)
-                sameModelDefaultRole = snapshot;
-            else
-                drop({ key: 'roles', at: 'default', ...refOf(model), reason: 'shadowed' });
+    for (const [role, t] of roleEntries ?? []) {
+        const first = guarded(() => {
+            const r = asRec(t);
+            const has = r !== undefined && Object.hasOwn(r, 'model');
+            return { tr: r, has, model: has ? r.model : undefined };
+        });
+        if (first === undefined) {
+            drop({ key: 'roles', at: role, reason: 'unreadable' });
             continue;
         }
-        const tr = asRec(t);
-        const model = tr && Object.hasOwn(tr, 'model') ? tr.model : undefined;
+        const { tr, has, model } = first;
         if (typeof model === 'string') {
             const verdict = modelRefVerdict(model);
             if (verdict !== 'accepted') {
@@ -243,12 +269,15 @@ function modelsDocOf(models, opts) {
                 continue;
             }
         }
-        setOwn(keptRoles, role, t);
+        const copy = writtenCopyOf(t, tr !== undefined && has ? { key: 'model', value: model } : undefined);
+        if (copy === undefined) {
+            drop({ key: 'roles', at: role, ...refOf(model), reason: 'unreadable' });
+            continue;
+        }
+        setOwn(keptRoles, role, copy.value);
     }
     const rolesOut = {};
-    if (defaultRole !== undefined)
-        setOwn(rolesOut, 'default', sameModelDefaultRole ?? defaultRole);
-    else if (Object.hasOwn(keptRoles, 'default'))
+    if (Object.hasOwn(keptRoles, 'default'))
         setOwn(rolesOut, 'default', keptRoles.default);
     for (const [k, v] of Object.entries(keptRoles))
         if (k !== 'default')
@@ -257,11 +286,9 @@ function modelsDocOf(models, opts) {
         doc.roles = rolesOut;
     const am = policy.atMention;
     if (am?.kind === 'unreadable') {
-        drop({ key: 'atMention', at: am.from, reason: 'unreadable' });
+        drop({ key: 'atMention', at: 'atMention', reason: 'unreadable' });
     }
     else if (am !== undefined) {
-        for (let i = 0; i < am.unreadableEntries; i += 1)
-            drop({ key: 'atMention', reason: 'unreadable' });
         const v = am.value;
         if (v.mode === 'only') {
             for (const n of v.models)
@@ -341,7 +368,7 @@ function modelsDocOf(models, opts) {
                 drop({ key: 'activeTierGroup', ...refOf(a), reason: typeof a === 'string' && a !== '' ? (rawGroupNames.has(a) ? 'rejected' : 'dangling') : 'unreadable' });
         }
     }
-    return { doc, issues };
+    return { doc, issues, entriesRead: copied };
 }
 export function cloudModelsToDoc(models, opts) {
     return modelsDocOf(models, opts).doc;
@@ -385,6 +412,10 @@ export function cloudModelMissingKeyEnv(doc, env) {
     }
     return [...out];
 }
+function mirrorUrlOf(raw) {
+    const r = normalizeEngineBaseUrl(raw);
+    return r.ok ? r.url : raw;
+}
 export function cloudExecutionToPolicy(execution) {
     const e = asRec(execution);
     const lanes = asArr(e?.allowedLanes).filter((l) => typeof l === 'string' && l.length > 0);
@@ -393,7 +424,7 @@ export function cloudExecutionToPolicy(execution) {
     return {
         required: e?.required === true,
         allowedLanes: lanes.length > 0 ? lanes : ['host'],
-        sessionMirror: mirrorUrl ? { engineUrl: mirrorUrl.replace(/\/+$/, ''), required: m?.required === true } : null,
+        sessionMirror: mirrorUrl ? { engineUrl: mirrorUrlOf(mirrorUrl), required: m?.required === true } : null,
     };
 }
 export function cloudRosterNames(rostersValue) {
@@ -549,7 +580,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
         return name && hash && skillBodies[hash] === undefined ? name : undefined;
     })
         .filter((n) => !!n);
-    const { doc: modelsDoc, issues: modelRefIssues } = modelsDocOf(config.models, opts);
+    const { doc: modelsDoc, issues: modelRefIssues, entriesRead } = modelsDocOf(config.models, opts);
     const view = viewModeOf(b);
     return {
         mcp,
@@ -561,7 +592,7 @@ export function projectEffectiveBody(body, skillBodies, env, rostersValue, opts)
         scope: asStr(b.scope) ?? 'global',
         skillsMissingBody,
         droppedMcpServers,
-        droppedModels: cloudModelsDropped(config.models),
+        droppedModels: entriesRead === undefined ? [] : cloudModelsDropped({ models: entriesRead }),
         execution: cloudExecutionToPolicy(config.execution),
         effectiveWarnings: effectiveWarningsOf(b),
         budget: budgetOf(b, view),
@@ -597,12 +628,12 @@ function droppedRefNotice(d) {
         case 'models':
             return { level: 'warn', text: `cloud config: ${t === undefined ? 'a model entry' : `model "${t}"`} ${ENTRY_REJECTED} — it was left out of the local catalog` };
         case 'roles':
+            if (d.at === 'models')
+                return { level: 'warn', text: 'cloud config: the role settings served to you could not be read by this client — they were left out, so no roles are set on the local engine' };
             if (d.at === 'default' && d.reason === 'unreadable')
                 return { level: 'warn', text: 'cloud config: the default model setting could not be read, so it was left out — the local engine picks its default from roles and tiers instead' };
             if (d.reason === 'unvouched')
                 return { level: 'warn', text: `cloud config: role "${d.at ?? ''}" points at model "${t ?? ''}", but this client was given no way to check that the local engine can use that model — the role was left out and falls back along the engine's role chain` };
-            if (d.reason === 'shadowed')
-                return { level: 'warn', text: `cloud config: the "${d.at ?? ''}" role${t === undefined ? '' : ` ("${t}")`} is overridden by the default model setting served to you — only one default model can be set, so that role entry was left out` };
             return { level: 'warn', text: `cloud config: role "${d.at ?? ''}" ${t === undefined ? 'names no readable model' : `points at model "${t}", which ${notServed}`} — the role was left out and falls back along the engine's role chain` };
         case 'atMention':
             if (d.at === 'atMention' && d.reason === 'dangling')
@@ -637,6 +668,14 @@ const MCP_DROP_SENTENCES = {
         level: 'warn',
         text: (who) => `cloud config: MCP server entries left out because they set both principalHeader and assertionHeader, which name the same identity header — keep only one of the two: ${who}`,
     },
+    'tool-axes-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudToolAxesInvalid', { who })),
+    },
+    'elicitation-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudElicitationInvalid', { who })),
+    },
     capped: {
         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}`,
@@ -790,6 +829,9 @@ export function cloudEffectiveNotices(p) {
         });
     }
     out.push(...droppedMcpNotices(p));
+    const assertionLine = mcpAssertionHeaderNotSentNotice(guarded(() => readOwnDataValue(p, 'mcp')) ?? []);
+    if (assertionLine !== undefined)
+        out.push({ level: 'warn', text: `cloud config: ${assertionLine}` });
     out.push(budgetNotice(p.budget));
     out.push(runtimeCapsNotice(p.runtimeCaps));
     return out;

package/dist/compensations.js

@@ -89,7 +89,7 @@ export const MIGRATED_COMPENSATIONS = [
         what: '从落盘转录的 `<task-notification>` XML 反解回植去重键 —— 去重面纯内存,重启即蒸发,' +
             '「通知 user-turn 已落盘、ack 未落」的 crash 窗口会二次喂模型(#63)',
         disposition: 'in-library',
-        libraryHalf: 'notifications.ts parseTranscriptNotificationSeeds(**唯一一份**解析)+ ' +
+        libraryHalf: 'notifications.ts parseTranscriptNotificationSeeds(**唯一一份**解析;0.98.0 起逐块解析归线性块解析器,单条口 readTaskNotificationXml 读同一只)+ ' +
             'adapt.ts importLedgerFromTranscript(消费口)',
         chromeArm: null,
         hostHalf: null,

package/dist/connectorStatus.d.ts

@@ -0,0 +1,21 @@
+import type { ReaderMintedStatus } from '@sema-agent/connectors-contract';
+import type { McpDeploymentOutcome } from './mcpProbeWire.js';
+export type { ReaderMintedState, ReaderMintedStatus } from '@sema-agent/connectors-contract';
+export declare const CONNECTOR_STATUS_UNKNOWN_WHYS: readonly ["name_unreadable", "mount_face_unreadable", "ambiguous", "unobserved", "probe_face_unreadable", "probe_undecided"];
+export type ConnectorStatusUnknownWhy = (typeof CONNECTOR_STATUS_UNKNOWN_WHYS)[number];
+export interface ConnectorStatusInput {
+    name: string;
+    mountFace: McpDeploymentOutcome;
+}
+export type ConnectorStatusReading = {
+    readonly kind: 'reader';
+    readonly status: Readonly<ReaderMintedStatus>;
+} | {
+    readonly kind: 'self_reported';
+    readonly state: 'unknown';
+} | {
+    readonly kind: 'unknown';
+    readonly why: ConnectorStatusUnknownWhy;
+};
+export declare function connectorStatusOf(input: ConnectorStatusInput): ConnectorStatusReading;
+export declare function connectorStatusLine(reading: ConnectorStatusReading, lang?: string): string;

package/dist/connectorStatus.js

@@ -0,0 +1,112 @@
+import { mcpEngineLegLivenessOf } from './mcpEngineLeg.js';
+export const CONNECTOR_STATUS_UNKNOWN_WHYS = Object.freeze([
+    'name_unreadable',
+    'mount_face_unreadable',
+    'ambiguous',
+    'unobserved',
+    'probe_face_unreadable',
+    'probe_undecided',
+]);
+void true;
+const readerReading = (state) => Object.freeze({ kind: 'reader', status: Object.freeze({ state }) });
+const READER_READINGS = Object.freeze({
+    unmounted: readerReading('unmounted'),
+    unreachable: readerReading('unreachable'),
+});
+const SELF_REPORTED = Object.freeze({ kind: 'self_reported', state: 'unknown' });
+const UNKNOWN_READINGS = Object.freeze(Object.fromEntries(CONNECTOR_STATUS_UNKNOWN_WHYS.map((why) => [why, Object.freeze({ kind: 'unknown', why })])));
+const BY_LIVENESS = Object.freeze({
+    reachable: SELF_REPORTED,
+    unreachable: READER_READINGS.unreachable,
+    unknown: UNKNOWN_READINGS.probe_undecided,
+});
+const UNREADABLE = Symbol('connectorStatus.unreadable');
+function ownField(o, key) {
+    if (o === null || typeof o !== 'object')
+        return undefined;
+    try {
+        if (!Object.hasOwn(o, key))
+            return undefined;
+        return o[key];
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function mountRowsOf(outcome) {
+    if (ownField(outcome, 'status') !== 'face')
+        return undefined;
+    if (ownField(outcome, 'declaredBy') !== 'deployment')
+        return undefined;
+    const faceView = ownField(outcome, 'face');
+    const servers = ownField(faceView, 'servers');
+    if (servers === UNREADABLE || servers === undefined)
+        return undefined;
+    return servers;
+}
+function readingOfLiveness(lv) {
+    switch (lv.kind) {
+        case 'not-listed':
+            return READER_READINGS.unmounted;
+        case 'unobserved':
+            return UNKNOWN_READINGS.mount_face_unreadable;
+        case 'ambiguous':
+            return UNKNOWN_READINGS.ambiguous;
+        case 'absent':
+            return UNKNOWN_READINGS.unobserved;
+        case 'unreadable':
+            return UNKNOWN_READINGS.probe_face_unreadable;
+        case 'observed':
+            return Object.hasOwn(BY_LIVENESS, lv.state) ? BY_LIVENESS[lv.state] : UNKNOWN_READINGS.probe_face_unreadable;
+        default: {
+            const exhaustive = lv;
+            void exhaustive;
+            return UNKNOWN_READINGS.mount_face_unreadable;
+        }
+    }
+}
+export function connectorStatusOf(input) {
+    const name = ownField(input, 'name');
+    if (typeof name !== 'string' || name === '')
+        return UNKNOWN_READINGS.name_unreadable;
+    const rows = mountRowsOf(ownField(input, 'mountFace'));
+    if (rows === undefined)
+        return UNKNOWN_READINGS.mount_face_unreadable;
+    let lv;
+    try {
+        lv = mcpEngineLegLivenessOf(name, rows);
+    }
+    catch {
+        return UNKNOWN_READINGS.mount_face_unreadable;
+    }
+    return readingOfLiveness(lv);
+}
+const READER_LINES = Object.freeze({
+    unmounted: "This connector is not mounted by default: this deployment's default MCP server list does not include it.",
+    unreachable: 'This connector is mounted, but the engine could not reach it when it last tried.',
+});
+const SELF_REPORTED_LINE = 'This connector is mounted and the engine reached it. Whether it is authorized is for the connector itself to report, and this client does not read that report.';
+const UNKNOWN_LINES = Object.freeze({
+    name_unreadable: "This client cannot tell this connector's status: it was not given a server name to look up.",
+    mount_face_unreadable: "This client could not read this deployment's MCP server list, so it cannot tell whether this connector is mounted.",
+    ambiguous: "This deployment lists more than one MCP server under this connector's name, so this client cannot tell which one it is.",
+    unobserved: 'This connector is mounted, but the engine has no reachability reading for it.',
+    probe_face_unreadable: "This connector is mounted, but this client could not read the engine's reachability reading for it.",
+    probe_undecided: 'This connector is mounted; the engine tried to reach it but could not tell whether it is reachable.',
+});
+const FALLBACK_LINE = "This client cannot tell this connector's status.";
+export function connectorStatusLine(reading, lang) {
+    void lang;
+    const kind = ownField(reading, 'kind');
+    if (kind === 'reader') {
+        const state = ownField(ownField(reading, 'status'), 'state');
+        return typeof state === 'string' && Object.hasOwn(READER_LINES, state) ? READER_LINES[state] : FALLBACK_LINE;
+    }
+    if (kind === 'self_reported')
+        return ownField(reading, 'state') === 'unknown' ? SELF_REPORTED_LINE : FALLBACK_LINE;
+    if (kind === 'unknown') {
+        const why = ownField(reading, 'why');
+        return typeof why === 'string' && Object.hasOwn(UNKNOWN_LINES, why) ? UNKNOWN_LINES[why] : FALLBACK_LINE;
+    }
+    return FALLBACK_LINE;
+}