@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/bashExitReading.d.ts

@@ -0,0 +1,10 @@
+export interface BashFrameExit {
+    readonly exitCode: number | null;
+    readonly note?: string;
+}
+export interface BashExitReading {
+    readonly exitCode: number | null;
+    readonly benignNote: string | undefined;
+}
+export declare function bashExitOf(structured: unknown, parseFrame: () => BashFrameExit | null): BashExitReading;
+export declare function bashExitReadingFailed(r: BashExitReading): boolean;

package/dist/bashExitReading.js

@@ -0,0 +1,12 @@
+export function bashExitOf(structured, parseFrame) {
+    const s = typeof structured === 'object' && structured !== null ? structured : undefined;
+    const interp = typeof s?.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0 ? s.returnCodeInterpretation : undefined;
+    if (s?.type === 'bash' && typeof s.exitCode === 'number')
+        return { exitCode: s.exitCode, benignNote: interp };
+    const parsed = parseFrame();
+    const note = typeof parsed?.note === 'string' && parsed.note.length > 0 ? parsed.note : undefined;
+    return { exitCode: parsed?.exitCode ?? null, benignNote: interp ?? note };
+}
+export function bashExitReadingFailed(r) {
+    return r.exitCode !== null && r.exitCode !== 0 && r.benignNote === undefined;
+}

package/dist/callerCwdCapability.d.ts

@@ -7,10 +7,5 @@ export type CallerCwdReading = {
     value: boolean;
 };
 export declare function projectCallerCwdCapability(caps: unknown): CallerCwdReading | undefined;
-export declare function noteEngineCapsForCallerCwd(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedCallerCwd(baseUrl?: string | undefined): CallerCwdReading;
 export declare function callerCwdAdmitted(reading: CallerCwdReading | undefined): boolean;
-export declare function forgetCallerCwdReading(baseUrl: string | undefined): void;
-export declare function __resetCallerCwdReadingsForTests(): void;

package/dist/callerCwdCapability.js

@@ -1,13 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectCallerCwdCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'callerCwd'))
-            return { kind: 'not_reported' };
-        const v = caps.callerCwd;
+        const v = ownDataField(caps, 'callerCwd');
         if (v === undefined)
             return { kind: 'not_reported' };
         return typeof v === 'boolean' ? { kind: 'present', value: v } : undefined;
@@ -21,9 +19,6 @@ const reader = createEngineCapReader({
     project: projectCallerCwdCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForCallerCwd(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedCallerCwd(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -39,9 +34,3 @@ export function callerCwdAdmitted(reading) {
         return false;
     }
 }
-export function forgetCallerCwdReading(baseUrl) {
-    reader.forget(baseUrl);
-}
-export function __resetCallerCwdReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/centerWiringCapability.d.ts

@@ -15,11 +15,10 @@ export interface CenterWiringView {
     usageReport: boolean;
     issuer: string;
     caller?: CenterWiringCallerView;
+    worker?: string;
 }
 export type CenterWiringReading = {
     kind: 'unobserved';
-} | {
-    kind: 'not_reported';
 } | {
     kind: 'none';
 } | {
@@ -27,12 +26,7 @@ export type CenterWiringReading = {
     view: CenterWiringView;
 };
 export declare function projectCenterWiringCapability(caps: unknown): CenterWiringReading | undefined;
-export declare function noteEngineCapsForCenterWiring(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedCenterWiring(baseUrl?: string | undefined): CenterWiringReading;
 export type CallerQuotaLease = 'enforced' | 'not-enforced' | 'exhausted' | 'unobserved' | 'no-lease' | 'unknown';
 export declare function callerQuotaLease(reading: CenterWiringReading): CallerQuotaLease;
 export declare function centerWiringDoctorDetail(reading: CenterWiringReading): string;
-export declare function forgetCenterWiringReading(baseUrl: string | undefined): void;
-export declare function __resetCenterWiringReadingsForTests(): void;

package/dist/centerWiringCapability.js

@@ -1,12 +1,11 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalSeat(o, key) {
-    if (!Object.hasOwn(o, key))
-        return { state: 'absent' };
-    const value = o[key];
+    const value = ownDataField(o, key);
     return value === undefined ? { state: 'absent' } : { state: 'value', value };
 }
 export function projectCenterWiringCapability(caps) {
@@ -20,16 +19,16 @@ export function projectCenterWiringCapability(caps) {
 function projectCenterWiringOf(caps) {
     if (!isPlainObject(caps))
         return undefined;
-    const cw = Object.hasOwn(caps, 'centerWiring') ? caps.centerWiring : undefined;
+    const cw = ownDataField(caps, 'centerWiring');
     if (cw === undefined)
-        return capsGenerationOf(caps).generation === 'new' ? { kind: 'none' } : { kind: 'not_reported' };
+        return { kind: 'none' };
     if (!isPlainObject(cw))
         return undefined;
-    const effectivePull = cw.effectivePull;
-    const revisionRaw = cw.effectiveRevision;
-    const lease = cw.lease;
-    const usageReport = cw.usageReport;
-    const issuer = cw.issuer;
+    const effectivePull = ownDataField(cw, 'effectivePull');
+    const revisionRaw = ownDataField(cw, 'effectiveRevision');
+    const lease = ownDataField(cw, 'lease');
+    const usageReport = ownDataField(cw, 'usageReport');
+    const issuer = ownDataField(cw, 'issuer');
     if (typeof effectivePull !== 'boolean' || typeof usageReport !== 'boolean')
         return undefined;
     if (!nonEmpty(lease) || !nonEmpty(issuer))
@@ -41,8 +40,8 @@ function projectCenterWiringOf(caps) {
     else {
         if (!isPlainObject(revisionRaw))
             return undefined;
-        const version = revisionRaw.version;
-        const updatedAt = revisionRaw.updatedAt;
+        const version = ownDataField(revisionRaw, 'version');
+        const updatedAt = ownDataField(revisionRaw, 'updatedAt');
         if (typeof version !== 'number' || !Number.isFinite(version) || !nonEmpty(updatedAt))
             return undefined;
         effectiveRevision = { version, updatedAt };
@@ -58,7 +57,7 @@ function projectCenterWiringOf(caps) {
     if (callerSeat.state === 'value') {
         if (!isPlainObject(callerSeat.value))
             return undefined;
-        const callerLease = callerSeat.value.lease;
+        const callerLease = ownDataField(callerSeat.value, 'lease');
         if (!nonEmpty(callerLease))
             return undefined;
         const wait = optionalSeat(callerSeat.value, 'retryAfterSec');
@@ -66,6 +65,9 @@ function projectCenterWiringOf(caps) {
             return undefined;
         caller = { lease: callerLease, ...(wait.state === 'value' ? { retryAfterSec: wait.value } : {}) };
     }
+    const workerSeat = optionalSeat(cw, 'worker');
+    if (workerSeat.state === 'value' && !nonEmpty(workerSeat.value))
+        return undefined;
     return {
         kind: 'present',
         view: {
@@ -77,6 +79,7 @@ function projectCenterWiringOf(caps) {
             usageReport,
             issuer,
             ...(caller !== undefined ? { caller } : {}),
+            ...(workerSeat.state === 'value' ? { worker: workerSeat.value } : {}),
         },
     };
 }
@@ -85,9 +88,6 @@ const reader = createEngineCapReader({
     project: projectCenterWiringCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForCenterWiring(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedCenterWiring(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -96,7 +96,7 @@ function guarded(reading) {
         return undefined;
     try {
         const kind = reading.kind;
-        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'none')
+        if (kind === 'unobserved' || kind === 'none')
             return { kind };
         if (kind !== 'present')
             return undefined;
@@ -158,9 +158,6 @@ function failModeClause(v) {
 export function centerWiringDoctorDetail(reading) {
     const unobserved = 'center wiring not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this engine is connected to a configuration center is unknown';
     const r = guarded(reading);
-    if (r?.kind === 'not_reported') {
-        return 'center wiring not reported by this engine; this does not say whether the engine is connected to a configuration center';
-    }
     if (r?.kind === 'none') {
         return 'no configuration center on this deployment — the engine runs on its own local configuration; no quota lease or usage reporting goes through a center';
     }
@@ -194,9 +191,3 @@ export function centerWiringDoctorDetail(reading) {
         return unobserved;
     }
 }
-export function forgetCenterWiringReading(baseUrl) {
-    reader.forget(baseUrl);
-}
-export function __resetCenterWiringReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/classifierStatus.js

@@ -1,4 +1,5 @@
 import { classifierDenyCauseOf } from './autoModeUnavailable.js';
+import { readAskOrigin } from './ownKey.js';
 export const CLASSIFIER_STATUS_STATES = Object.freeze([
     'armed',
     'available',
@@ -8,14 +9,13 @@ const CLASSIFIER_RAN_ORIGINS = new Set(['denial_limit_fallback']);
 function askOriginOf(ask) {
     if (typeof ask !== 'object' || ask === null || Array.isArray(ask))
         return undefined;
-    const top = ask.origin;
-    if (typeof top === 'string' && top.length > 0)
+    const top = readAskOrigin(ask);
+    if (top !== undefined)
         return top;
     const gate = ask.gate;
     if (typeof gate !== 'object' || gate === null || Array.isArray(gate))
         return undefined;
-    const inner = gate.origin;
-    return typeof inner === 'string' && inner.length > 0 ? inner : undefined;
+    return readAskOrigin(gate);
 }
 const NOT_A_ROUND_FAILURE = new Set(['parse_error']);
 export function classifierStatusOf(autoMode, ask) {

package/dist/classifierVerdictWire.js

@@ -1,21 +1,7 @@
 import { unwrapSystemReminder } from './systemReminderTag.js';
+import { toolEndOutputText } from './toolResultContent.js';
 export const CLASSIFIER_DENY_SIGNATURE = 'auto-mode classifier blocked this call';
 const NOTICE_REASON_MAX = 80;
-function textFromWireOutput(output) {
-    if (typeof output === 'string')
-        return output;
-    const blocks = Array.isArray(output)
-        ? output
-        : output !== null && typeof output === 'object' && Array.isArray(output.content)
-            ? (output.content)
-            : undefined;
-    if (!blocks)
-        return undefined;
-    const texts = blocks
-        .map(b => (b !== null && typeof b === 'object' && typeof b.text === 'string' ? b.text : undefined))
-        .filter((t) => t !== undefined);
-    return texts.length > 0 ? texts.join('\n') : undefined;
-}
 const CLASSIFIER_DENY_FORMS = [
     'auto-mode classifier blocked the approved edit at an inherited ancestor layer',
     'auto-mode classifier blocked this call at an inherited ancestor layer',
@@ -24,7 +10,9 @@ const CLASSIFIER_DENY_FORMS = [
 export function classifierDenyFromToolEnd(ev) {
     if (!ev || ev.type !== 'tool_end' || ev.isError !== true)
         return undefined;
-    const raw = textFromWireOutput(ev.output);
+    if (Array.isArray(ev.output) && ev.output.length !== 1)
+        return undefined;
+    const raw = toolEndOutputText(ev.output);
     if (raw === undefined)
         return undefined;
     const message = unwrapSystemReminder(raw).trim();

package/dist/clientSlice.js

@@ -14,4 +14,4 @@ export const CLIENT_VERBS = [
     { 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 头。';
+    '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';
+export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'capped' | 'principal-and-assertion-header';
 export interface CloudMcpDroppedServer {
     name?: string;
     reason: CloudMcpDropReason;
@@ -17,10 +17,10 @@ export interface CloudMcpProjection {
 export declare function cloudMcpToSpecs(servers: unknown, env: EnvLike): CloudMcpProjection;
 export declare function cloudSkillsToSpecs(manifestSkills: unknown, resolveBody: (contentHash: string) => string | null): SkillSpec[];
 export interface CloudModelRefIssue {
-    readonly key: 'models' | 'default' | 'roles' | 'atModelAllowlist' | 'tierGroups' | 'activeTierGroup';
+    readonly key: 'models' | 'roles' | 'atMention' | 'tierGroups' | 'activeTierGroup';
     readonly at?: string;
     readonly target?: string;
-    readonly reason: 'dangling' | 'rejected' | 'unreadable' | 'unsupported' | 'duplicate';
+    readonly reason: 'dangling' | 'rejected' | 'unreadable' | 'unsupported' | 'duplicate' | 'shadowed';
     readonly outcome: 'dropped' | 'kept';
 }
 export interface CloudModelsDocOptions {

package/dist/cloudConfigWireCaps.js

@@ -1,6 +1,8 @@
 import { MCP_CAPS } from './mcpWireCaps.js';
 import { toCappedSpec } from './skillsWireCaps.js';
 import { TIER_ORDER } from './model/tierVocabulary.js';
+import { SETTINGS_NARROW_AT_MENTION } from './generated/settingsSchemaFns.js';
+import { modelsPolicyOf } from './model/modelsPolicy.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 : []);
@@ -60,6 +62,10 @@ export function cloudMcpToSpecs(servers, env) {
                 drop(name, 'missing-field');
                 continue;
             }
+            if (asStr(t.principalHeader) && asStr(t.assertionHeader)) {
+                drop(name, 'principal-and-assertion-header');
+                continue;
+            }
             const headers = {};
             for (const [headerName, ref] of Object.entries(asRec(t.headerRefs) ?? {})) {
                 const refName = asStr(ref);
@@ -164,8 +170,10 @@ function modelsDocOf(models, opts) {
     const refOf = (v) => (typeof v === 'string' && v !== '' ? { target: v } : {});
     const reasonOf = (v) => typeof v === 'string' && v !== '' ? (rawNames.has(v) ? 'rejected' : 'dangling') : 'unreadable';
     let written = stripped;
+    let catalogKept = false;
     if (acceptedFlags && stripped.length > 0) {
         const anyAccepted = acceptedFlags.some((f) => f);
+        catalogKept = !anyAccepted;
         stripped.forEach((e, i) => {
             if (!acceptedFlags[i])
                 issues.push({ key: 'models', target: e.name, reason: 'rejected', outcome: anyAccepted ? 'dropped' : 'kept' });
@@ -174,40 +182,81 @@ function modelsDocOf(models, opts) {
             written = stripped.filter((_, i) => acceptedFlags[i]);
     }
     const doc = { models: written };
-    if (accept && Object.hasOwn(m, 'default')) {
-        const d = m.default;
-        if (typeof d === 'string' && names.has(d))
-            doc.default = d;
+    const policy = modelsPolicyOf(m);
+    if (policy.unreadable) {
+        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;
+    if (accept && dm !== undefined && dm.from === 'default') {
+        if (names.has(dm.name))
+            defaultRole = { model: dm.name };
         else
-            drop({ key: 'default', ...refOf(d), reason: reasonOf(d) });
+            drop({ key: 'roles', at: 'default', target: dm.name, reason: reasonOf(dm.name) });
     }
     const roles = asRec(m.roles);
-    if (roles) {
-        const kept = {};
-        for (const [role, t] of Object.entries(roles)) {
-            const tr = asRec(t);
-            const model = tr && Object.hasOwn(tr, 'model') ? tr.model : undefined;
-            if (typeof model === 'string' && !names.has(model)) {
-                drop({ key: 'roles', at: role, ...refOf(model), reason: reasonOf(model) });
-                continue;
+    const keptRoles = {};
+    for (const [role, t] of Object.entries(roles ?? {})) {
+        if (role === 'default' && defaultRole !== undefined) {
+            let same = false;
+            try {
+                same = JSON.stringify(t) === JSON.stringify(defaultRole);
+            }
+            catch {
+                same = false;
             }
-            setOwn(kept, role, t);
+            if (!same) {
+                const tr = asRec(t);
+                const model = tr && Object.hasOwn(tr, 'model') ? tr.model : undefined;
+                drop({ key: 'roles', at: 'default', ...refOf(model), reason: 'shadowed' });
+            }
+            continue;
+        }
+        const tr = asRec(t);
+        const model = tr && Object.hasOwn(tr, 'model') ? tr.model : undefined;
+        if (typeof model === 'string' && !names.has(model)) {
+            drop({ key: 'roles', at: role, ...refOf(model), reason: reasonOf(model) });
+            continue;
         }
-        doc.roles = kept;
+        setOwn(keptRoles, role, t);
     }
-    if (Array.isArray(m.atModelAllowlist)) {
-        const src = m.atModelAllowlist;
-        const keep = src.filter((n) => typeof n === 'string' && names.has(n));
-        if (keep.length === 0 && src.length > 0) {
-            doc.atModelAllowlist = src;
-            for (const n of src)
-                issues.push({ key: 'atModelAllowlist', ...refOf(n), reason: reasonOf(n), outcome: 'kept' });
+    const rolesOut = {};
+    if (defaultRole !== undefined)
+        setOwn(rolesOut, 'default', defaultRole);
+    else if (Object.hasOwn(keptRoles, 'default'))
+        setOwn(rolesOut, 'default', keptRoles.default);
+    for (const [k, v] of Object.entries(keptRoles))
+        if (k !== 'default')
+            setOwn(rolesOut, k, v);
+    if (Object.keys(rolesOut).length > 0)
+        doc.roles = rolesOut;
+    const am = policy.atMention;
+    if (am?.kind === 'unreadable') {
+        drop({ key: 'atMention', at: am.from, 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)
+                if (!names.has(n))
+                    drop({ key: 'atMention', target: n, reason: reasonOf(n) });
+            const narrowed = SETTINGS_NARROW_AT_MENTION(v, names);
+            if (narrowed.mode === 'only') {
+                doc.atMention = { mode: 'only', models: [...narrowed.models] };
+            }
+            else {
+                doc.atMention = { mode: narrowed.mode };
+                if (narrowed.mode === 'none' && !catalogKept)
+                    drop({ key: 'atMention', at: 'atMention', reason: 'dangling' });
+            }
         }
-        else {
-            for (const n of src)
-                if (!(typeof n === 'string' && names.has(n)))
-                    drop({ key: 'atModelAllowlist', ...refOf(n), reason: reasonOf(n) });
-            doc.atModelAllowlist = keep;
+        else if (v.mode === 'none') {
+            doc.atMention = { mode: 'none' };
         }
     }
     let groupNames;
@@ -494,8 +543,6 @@ const ENTRY_REJECTED = `is in the catalog, but its entry is one the local engine
 function warningNotice(w) {
     const where = quoted(w.domain, 'the configuration');
     switch (w.kind) {
-        case 'hosts-grandfathered':
-            return { level: 'warn', text: `cloud config warning: host entries exceeding the current limits were skipped by the registry${listOf(w.droppedNames, w.truncatedFrom)}` };
         case 'domain-defaulted':
             return { level: 'warn', text: `cloud config warning: ${where} could not be read by the registry and were served as defaults — what is configured there is not in effect` };
         case 'entry-dropped':
@@ -504,8 +551,6 @@ function warningNotice(w) {
             return { level: 'warn', text: `cloud config warning: the registry dropped unrecognised keys from ${where}${listOf(w.keys, w.truncatedFrom)}` };
         case 'unknown-keys-carried':
             return { level: 'warn', text: `cloud config warning: ${where} carry keys the registry does not recognise, passed on as written (check the spelling)${listOf(w.keys, w.truncatedFrom)}` };
-        case 'legacy-governance-lifted':
-            return { level: 'info', text: `cloud config note: ${where} were taken from their older location${listOf(w.keys, undefined)}` };
         case 'unread-config-file':
             return { level: 'warn', text: `cloud config warning: a configuration file was not read by the registry${w.file === undefined ? '' : ` (${w.file}${w.why === undefined ? '' : `: ${w.why}`})`}` };
         default:
@@ -518,11 +563,17 @@ function droppedRefNotice(d) {
     switch (d.key) {
         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 'default':
-            return { level: 'warn', text: `cloud config: ${t === undefined ? 'the default model setting could not be read' : `the default model "${t}" ${notServed}`}, so it was left out — the local engine picks its default from roles and tiers instead` };
         case 'roles':
+            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 === '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 'atModelAllowlist':
+        case 'atMention':
+            if (d.at === 'atMention' && d.reason === 'dangling')
+                return { level: 'warn', text: 'cloud config: none of the models in the @-mention allowlist served to you can be used on the local engine, so @-mentions are turned off there' };
+            if (d.at !== undefined)
+                return { level: 'warn', text: 'cloud config: the @-mention setting served to you could not be read by this client — it was left out, so @-mentions are not restricted on the local engine' };
             return { level: 'warn', text: `cloud config: ${t === undefined ? 'an unreadable @-mention allowlist entry' : `@-mention allowlist entry "${t}" ${notServed} and`} was left out` };
         case 'tierGroups':
             if (d.reason === 'duplicate')
@@ -603,15 +654,6 @@ export function cloudEffectiveNotices(p) {
                 'the catalog is kept as sent, and a locally started engine rejects the cloud model settings: at startup it uses its own environment catalog instead, and on a later refresh it keeps the previous configuration',
         });
     }
-    const keptAllowlist = p.modelRefIssues.filter((d) => d.outcome === 'kept' && d.key === 'atModelAllowlist');
-    if (keptAllowlist.length > 0) {
-        const names = keptAllowlist.flatMap((d) => (d.target === undefined ? [] : [`"${d.target}"`]));
-        out.push({
-            level: 'warn',
-            text: `cloud config: no @-mention allowlist entry${names.length > 0 ? ` (${names.join(', ')})` : ''} names a usable model in the catalog served to you — ` +
-                'the list is kept as sent, because an empty list would let every model be mentioned; with it, a locally started engine rejects the cloud model settings — at startup it uses its own environment catalog instead, and on a later refresh it keeps the previous configuration',
-        });
-    }
     out.push(budgetNotice(p.budget));
     out.push(runtimeCapsNotice(p.runtimeCaps));
     return out;

package/dist/compensations.js

@@ -93,7 +93,7 @@ export const MIGRATED_COMPENSATIONS = [
             'adapt.ts importLedgerFromTranscript(消费口)',
         chromeArm: null,
         hostHalf: null,
-        retireOn: 'RL-37',
+        retireOn: null,
     },
     {
         id: 'T25',

package/dist/coreValuePorts.d.ts

@@ -91,17 +91,21 @@ export interface PerModelAuthView {
     apiKey?: string;
     headers?: Record<string, string>;
 }
+export type RuleGrammarView = 'command' | 'domain' | 'name' | 'path';
+export interface RuleToolNameVerdictView {
+    readonly kind: 'current' | 'retired' | 'unprefixed_namespace' | 'unmintable_segment' | (string & {});
+    readonly guidance?: string;
+    readonly currentName?: string;
+}
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
     combinePolicies: (...policies: CoreToolPolicyHandle[]) => CoreToolPolicyHandle;
     createAllowDenyPolicy: (opts: AllowDenyPolicyOptionsView) => CoreToolPolicyHandle;
     MCP_NAMESPACE: CoreProtocolNamespaceView;
-    RETIRED_TOOL_NAMES: ReadonlyMap<string, string>;
     protocolOf: (name: string) => CoreProtocolNamespaceView | undefined;
-    ruleToolGrammarOf: (toolName: string) => 'command' | 'path' | undefined;
+    ruleToolGrammarOf: (toolName: string) => RuleGrammarView | undefined;
     validatePermissionRules: (rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView) => PermissionRuleIssueView[];
-    DISCUSSION_WORKFLOW_NAME: string;
     mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string;
     compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView;
     routeKeyOf(url: string | undefined): string;
@@ -113,8 +117,9 @@ export interface CoreValuePorts {
     routePairingStatus(brain: {
         adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
     }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView;
+    judgeRuleToolName(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "RETIRED_TOOL_NAMES", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "DISCUSSION_WORKFLOW_NAME", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -125,13 +130,12 @@ export declare function loosenReasons(prior: SessionPermissionRules, next: Sessi
 export declare function combinePolicies(...policies: CoreToolPolicyHandle[]): CoreToolPolicyHandle | undefined;
 export declare function createAllowDenyPolicy(opts: AllowDenyPolicyOptionsView): CoreToolPolicyHandle | undefined;
 export declare function mcpNamespace(): CoreProtocolNamespaceView | undefined;
-export declare function retiredToolNames(): ReadonlyMap<string, string> | undefined;
 export declare function protocolOf(name: string): CoreProtocolNamespaceView | undefined;
-export declare function ruleToolGrammarOf(toolName: string): 'command' | 'path' | undefined;
+export declare function ruleToolGrammarOf(toolName: string): RuleGrammarView | undefined;
 export declare function validatePermissionRules(rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView): PermissionRuleIssueView[] | undefined;
-export declare function discussionWorkflowName(): string | undefined;
 export declare function mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string | undefined;
 export declare function compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView | undefined;
+export declare function ruleToolNameJudgement(name: string, roster: ReadonlySet<string>): RuleToolNameVerdictView | undefined;
 export declare function routeKeyOf(url: string | undefined): string | undefined;
 export declare function joinRequestUrl(root: string | undefined, suffix: string): string | undefined;
 export declare function resolveRouteCredential(input: RouteCredentialInputView): RouteCredentialView | undefined;

package/dist/coreValuePorts.js

@@ -4,11 +4,9 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'combinePolicies',
     'createAllowDenyPolicy',
     'MCP_NAMESPACE',
-    'RETIRED_TOOL_NAMES',
     'protocolOf',
     'ruleToolGrammarOf',
     'validatePermissionRules',
-    'DISCUSSION_WORKFLOW_NAME',
     'mintNamespacePrefix',
     'compileAllowList',
     'routeKeyOf',
@@ -16,6 +14,7 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'resolveRouteCredential',
     'adjudicateModelRoute',
     'routePairingStatus',
+    'judgeRuleToolName',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -56,9 +55,6 @@ export function createAllowDenyPolicy(opts) {
 export function mcpNamespace() {
     return port('MCP_NAMESPACE');
 }
-export function retiredToolNames() {
-    return port('RETIRED_TOOL_NAMES');
-}
 export function protocolOf(name) {
     const fn = port('protocolOf');
     return fn === undefined ? undefined : fn(name);
@@ -71,9 +67,6 @@ export function validatePermissionRules(rules, opts) {
     const fn = port('validatePermissionRules');
     return fn === undefined ? undefined : fn(rules, opts);
 }
-export function discussionWorkflowName() {
-    return port('DISCUSSION_WORKFLOW_NAME');
-}
 export function mintNamespacePrefix(ns, peer) {
     const fn = port('mintNamespacePrefix');
     return fn === undefined ? undefined : fn(ns, peer);
@@ -82,6 +75,10 @@ export function compileAllowList(entries, behavior, roster) {
     const fn = port('compileAllowList');
     return fn === undefined ? undefined : fn(entries, behavior, roster);
 }
+export function ruleToolNameJudgement(name, roster) {
+    const fn = port('judgeRuleToolName');
+    return fn === undefined ? undefined : fn(name, roster);
+}
 export function routeKeyOf(url) {
     const fn = port('routeKeyOf');
     return fn === undefined ? undefined : fn(url);

package/dist/credentialProvenance.d.ts

@@ -0,0 +1,28 @@
+export declare const CREDENTIAL_ATTACH_WORDS: readonly ["local-sidecar", "service-token", "registry", "none"];
+export type CredentialAttachWord = (typeof CREDENTIAL_ATTACH_WORDS)[number];
+declare const TARGET_KIND_WORDS: readonly ["local-managed", "loopback-pin", "remote", "unresolved"];
+declare const TARGET_PROVENANCE_WORDS: readonly ["managed", "connect-pin", "manual", "none"];
+declare const CONSENT_WORDS: readonly ["granted", "absent", "n/a"];
+declare const SIDECAR_OWNERSHIP_WORDS: readonly ["verified", "mismatch"];
+export type CredentialTargetKind = (typeof TARGET_KIND_WORDS)[number];
+export type CredentialTargetProvenance = (typeof TARGET_PROVENANCE_WORDS)[number];
+export type CredentialConsent = (typeof CONSENT_WORDS)[number];
+export type CredentialSidecarOwnership = (typeof SIDECAR_OWNERSHIP_WORDS)[number];
+export interface CredentialFacts {
+    readonly kind: CredentialTargetKind;
+    readonly provenance?: CredentialTargetProvenance;
+    readonly sidecarOwnership?: CredentialSidecarOwnership;
+    readonly serviceTokenAtFirstWrite?: boolean;
+    readonly loggedIn?: boolean;
+    readonly consent?: CredentialConsent;
+}
+export type CredentialFactName = 'facts' | 'kind' | 'sidecarOwnership' | 'serviceTokenAtFirstWrite' | 'loggedIn' | 'provenance' | 'consent';
+export type CredentialProvenance = {
+    readonly kind: 'word';
+    readonly word: CredentialAttachWord;
+} | {
+    readonly kind: 'unreadable';
+    readonly reason: CredentialFactName;
+};
+export declare function credentialProvenance(facts: CredentialFacts): CredentialProvenance;
+export {};