@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/localEngineStopLadder.d.ts

@@ -0,0 +1,29 @@
+export declare const LOCAL_ENGINE_STOP_LADDER: Readonly<{
+    g: 1000;
+    P: 5000;
+    H: 20000;
+}>;
+export type StopLadderSignal = 'term' | 'term-2' | 'kill';
+export interface StopLadderState {
+    readonly mode: 'idle' | 'forced';
+    readonly target: {
+        readonly pid: number;
+        readonly startedAt?: number;
+    };
+    readonly t0: number;
+    readonly sent: readonly StopLadderSignal[];
+    readonly processedAt?: number;
+    readonly deadlineAt?: number;
+    readonly killedAt?: number;
+}
+export interface StopLadderObservation {
+    readonly nowMs: number;
+    readonly alive: 'alive' | 'gone' | 'unknown';
+    readonly health: object | null;
+}
+export interface StopLadderStepResult {
+    readonly state: StopLadderState;
+    readonly action: StopLadderSignal | 'wait' | 'done' | 'gave-up';
+    readonly waitMs?: number;
+}
+export declare function stopLadderStep(s: StopLadderState, obs: StopLadderObservation): StopLadderStepResult;

package/dist/localEngineStopLadder.js

@@ -0,0 +1,139 @@
+import { readEngineHealthFacts } from './engineHealthFacts.js';
+import { readOwnDataValue } from './ownKey.js';
+export const LOCAL_ENGINE_STOP_LADDER = Object.freeze({ g: 1000, P: 5000, H: 20000 });
+const SIGTERM_ACTION_ID = 'signal:SIGTERM';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTime(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+const SIGNALS = Object.freeze(['term', 'term-2', 'kill']);
+function stateOf(s) {
+    const mode = own(s, 'mode');
+    if (mode !== 'idle' && mode !== 'forced')
+        return undefined;
+    const target = own(s, 'target');
+    const pid = own(target, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const startedAt = own(target, 'startedAt');
+    const t0 = own(s, 't0');
+    if (!isTime(t0))
+        return undefined;
+    const sentRaw = own(s, 'sent');
+    let sent = [];
+    try {
+        if (!Array.isArray(sentRaw))
+            return undefined;
+        for (let i = 0; i < sentRaw.length; i++) {
+            const x = own(sentRaw, String(i));
+            if (!SIGNALS.includes(x))
+                return undefined;
+            if (!sent.includes(x))
+                sent.push(x);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    sent = SIGNALS.filter((x) => sent.includes(x));
+    const processedAt = own(s, 'processedAt');
+    const deadlineAt = own(s, 'deadlineAt');
+    const killedAt = own(s, 'killedAt');
+    if (processedAt !== undefined && !isTime(processedAt))
+        return undefined;
+    if (deadlineAt !== undefined && !isTime(deadlineAt))
+        return undefined;
+    if (killedAt !== undefined && !isTime(killedAt))
+        return undefined;
+    return {
+        mode,
+        target: isTime(startedAt) && startedAt > 0 ? { pid, startedAt } : { pid },
+        t0,
+        sent,
+        ...(processedAt !== undefined ? { processedAt } : {}),
+        ...(deadlineAt !== undefined ? { deadlineAt } : {}),
+        ...(killedAt !== undefined ? { killedAt } : {}),
+    };
+}
+function frozen(s) {
+    return Object.freeze({ ...s, target: Object.freeze({ ...s.target }), sent: Object.freeze([...s.sent]) });
+}
+function result(s, action, waitMs) {
+    return Object.freeze({ state: frozen(s), action, ...(waitMs !== undefined ? { waitMs: Math.max(0, waitMs) } : {}) });
+}
+export function stopLadderStep(s, obs) {
+    const st = stateOf(s);
+    if (st === undefined) {
+        return Object.freeze({ state: s, action: 'gave-up' });
+    }
+    const nowMs = own(obs, 'nowMs');
+    const alive = own(obs, 'alive');
+    if (alive === 'gone')
+        return result(st, 'done');
+    if (!isTime(nowMs))
+        return result(st, 'wait');
+    const { g, P, H } = LOCAL_ENGINE_STOP_LADDER;
+    const health = own(obs, 'health');
+    let facts;
+    try {
+        facts = typeof health === 'object' && health !== null ? readEngineHealthFacts(health) : undefined;
+    }
+    catch {
+        facts = undefined;
+    }
+    const draining = facts?.draining;
+    let next = st;
+    if (draining !== undefined) {
+        if (st.mode === 'idle') {
+            next = { ...next, deadlineAt: Math.max(st.deadlineAt ?? draining.deadlineAt, draining.deadlineAt) };
+        }
+        else if (st.processedAt === undefined && st.sent.includes('term') && draining.actionId === SIGTERM_ACTION_ID && draining.since >= st.t0) {
+            next = { ...next, processedAt: nowMs };
+        }
+    }
+    const isAlive = alive === 'alive';
+    if (next.sent.length === 0) {
+        if (isAlive)
+            return result({ ...next, sent: ['term'] }, 'term');
+        return result(next, nowMs >= next.t0 + H ? 'gave-up' : 'wait', next.t0 + H - nowMs);
+    }
+    const killAt = next.mode === 'idle'
+        ? Math.max(next.t0, next.deadlineAt ?? next.t0) + H
+        : next.processedAt !== undefined && next.processedAt <= next.t0 + P
+            ? next.processedAt + g + H
+            : next.t0 + H;
+    if (next.killedAt !== undefined || next.sent.includes('kill')) {
+        const giveUpAt = (next.killedAt ?? killAt) + H;
+        if (nowMs >= giveUpAt)
+            return result(next, 'gave-up');
+        return result(next, 'wait', giveUpAt - nowMs);
+    }
+    if (!isAlive) {
+        if (nowMs >= killAt)
+            return result(next, 'gave-up');
+        return result(next, 'wait', killAt - nowMs);
+    }
+    if (nowMs >= killAt)
+        return result({ ...next, sent: [...next.sent, 'kill'], killedAt: nowMs }, 'kill');
+    if (next.mode === 'forced' &&
+        next.processedAt !== undefined &&
+        nowMs >= next.processedAt + g &&
+        draining !== undefined &&
+        !next.sent.includes('term-2')) {
+        return result({ ...next, sent: [...next.sent.filter((x) => x !== 'kill'), 'term-2'] }, 'term-2');
+    }
+    const term2At = next.mode === 'forced' && next.processedAt !== undefined && !next.sent.includes('term-2') ? next.processedAt + g : Infinity;
+    return result(next, 'wait', Math.min(killAt, term2At) - nowMs);
+}

package/dist/localEngineSwapCard.d.ts

@@ -0,0 +1,43 @@
+import type { LocalEngineAnchoredProcess, LocalEngineRef } from './localEngineJudge.js';
+import type { LocalEngineOccupancy } from './localEngineOccupancy.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const LOCAL_ENGINE_SWAP_CAUSES: readonly ["version", "config", "credential", "model-default", "user", "unresponsive"];
+export type LocalEngineSwapCause = (typeof LOCAL_ENGINE_SWAP_CAUSES)[number];
+export interface LocalEngineSwapPolicy {
+    readonly credentialAuto?: boolean;
+}
+export declare function localEngineSwapAutoable(cause: LocalEngineSwapCause, serving: boolean, policy?: LocalEngineSwapPolicy): boolean;
+export type EngineSwapCardTarget = LocalEngineRef | LocalEngineAnchoredProcess;
+export type EngineSwapCardUnknown = 'others' | 'inflight' | 'bg' | 'self';
+export interface EngineSwapCardInput {
+    readonly cause: LocalEngineSwapCause;
+    readonly target: EngineSwapCardTarget;
+    readonly running?: string;
+    readonly own?: string;
+    readonly occupancy: LocalEngineOccupancy;
+    readonly bgIds: readonly string[] | null;
+}
+export interface EngineSwapCardOthers {
+    readonly total: number;
+    readonly midTurn: number;
+}
+export interface EngineSwapCard {
+    readonly cause: LocalEngineSwapCause;
+    readonly target: EngineSwapCardTarget;
+    readonly running?: string;
+    readonly own?: string;
+    readonly others: EngineSwapCardOthers | null;
+    readonly inflight: number | null;
+    readonly bgLive: number | null;
+    readonly unknown: readonly EngineSwapCardUnknown[];
+    readonly forcedWithinMs: number;
+    readonly fingerprint: string;
+}
+export declare function engineSwapCardOf(input: EngineSwapCardInput): EngineSwapCard | undefined;
+export interface EngineSwapCardText {
+    readonly title: string;
+    readonly lines: readonly string[];
+    readonly force: string;
+    readonly wait: string;
+}
+export declare function engineSwapCardText(card: EngineSwapCard, lang?: UiLanguage): EngineSwapCardText | undefined;

package/dist/localEngineSwapCard.js

@@ -0,0 +1,205 @@
+import { engineIdentityOf } from './engineIdentity.js';
+import { readOwnDataValue } from './ownKey.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { LOCAL_ENGINE_STOP_LADDER } from './localEngineStopLadder.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const LOCAL_ENGINE_SWAP_CAUSES = Object.freeze(['version', 'config', 'credential', 'model-default', 'user', 'unresponsive']);
+function isCause(v) {
+    return typeof v === 'string' && LOCAL_ENGINE_SWAP_CAUSES.includes(v);
+}
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function isArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (!isRecord(v) && !isArray(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCount(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+export function localEngineSwapAutoable(cause, serving, policy) {
+    if (!isCause(cause))
+        return false;
+    if (serving === false)
+        return true;
+    if (cause === 'version' || cause === 'user')
+        return true;
+    return cause === 'credential' && own(policy, 'credentialAuto') === true;
+}
+const FORCED_WITHIN_MS = LOCAL_ENGINE_STOP_LADDER.P + LOCAL_ENGINE_STOP_LADDER.g + LOCAL_ENGINE_STOP_LADDER.H;
+function targetOf(t) {
+    const pid = own(t, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const identity = own(t, 'identity');
+    if (isRecord(identity)) {
+        const port = own(t, 'port');
+        if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535)
+            return undefined;
+        const id = Object.freeze({ ...engineIdentityOf(identity) });
+        const version = own(t, 'version');
+        const target = Object.freeze({ pid, port, identity: id, ...(typeof version === 'string' && version.length > 0 ? { version } : {}) });
+        return { target, key: id };
+    }
+    const startedAt = own(t, 'startedAt');
+    const target = Object.freeze({ pid, ...(typeof startedAt === 'number' && Number.isFinite(startedAt) && startedAt > 0 ? { startedAt } : {}) });
+    return { target, key: engineIdentityOf(target) };
+}
+export function engineSwapCardOf(input) {
+    try {
+        const cause = own(input, 'cause');
+        if (!isCause(cause))
+            return undefined;
+        const t = targetOf(own(input, 'target'));
+        if (t === undefined)
+            return undefined;
+        const occ = own(input, 'occupancy');
+        const unknown = [];
+        const o = own(occ, 'others');
+        const total = own(o, 'total');
+        const midTurn = own(o, 'midTurn');
+        const others = own(o, 'known') === true && isCount(total) && isCount(midTurn) ? Object.freeze({ total, midTurn }) : null;
+        if (others === null)
+            unknown.push('others');
+        const inflightRaw = own(occ, 'inflight');
+        const inflight = isCount(inflightRaw) ? inflightRaw : null;
+        if (inflight === null)
+            unknown.push('inflight');
+        const bgRaw = own(occ, 'bgLive');
+        const idsRaw = own(input, 'bgIds');
+        let bgIds = null;
+        if (Array.isArray(idsRaw)) {
+            const list = [];
+            let readable = true;
+            for (let i = 0; i < idsRaw.length && readable; i++) {
+                const id = own(idsRaw, String(i));
+                if (typeof id === 'string')
+                    list.push(id);
+                else
+                    readable = false;
+            }
+            bgIds = readable ? list : null;
+        }
+        const bgLive = isCount(bgRaw) && bgIds !== null && bgIds.length === bgRaw ? bgRaw : null;
+        if (bgLive === null) {
+            unknown.push('bg');
+            bgIds = null;
+        }
+        const self = own(occ, 'self');
+        if (self !== 'idle' && self !== 'busy')
+            unknown.push('self');
+        const runningRaw = own(input, 'running');
+        const ownRaw = own(input, 'own');
+        const running = typeof runningRaw === 'string' && runningRaw.length > 0 ? runningRaw : undefined;
+        const mine = typeof ownRaw === 'string' && ownRaw.length > 0 ? ownRaw : undefined;
+        const k = t.key;
+        const fingerprint = JSON.stringify([
+            'local-engine-swap-card/1',
+            cause,
+            [t.target.pid, k.pid ?? null, k.instanceId ?? null, k.startedAt ?? null],
+            running ?? null,
+            mine ?? null,
+            others === null ? null : [others.total, others.midTurn],
+            inflight,
+            bgLive,
+            bgIds === null ? null : [...bgIds].sort(),
+            unknown,
+            self === 'idle' || self === 'busy' ? self : null,
+        ]);
+        return Object.freeze({
+            cause,
+            target: t.target,
+            ...(running !== undefined ? { running } : {}),
+            ...(mine !== undefined ? { own: mine } : {}),
+            others,
+            inflight,
+            bgLive,
+            unknown: Object.freeze(unknown),
+            forcedWithinMs: FORCED_WITHIN_MS,
+            fingerprint,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+const TITLE_KEYS = Object.freeze({
+    version: 'localEngine.card.title.version',
+    config: 'localEngine.card.title.config',
+    credential: 'localEngine.card.title.credential',
+    'model-default': 'localEngine.card.title.modelDefault',
+    user: 'localEngine.card.title.user',
+    unresponsive: 'localEngine.card.title.unresponsive',
+});
+const VERSION_DISPLAY_MAX = 64;
+export function engineSwapCardText(card, lang) {
+    try {
+        const cause = own(card, 'cause');
+        const forcedWithinMs = own(card, 'forcedWithinMs');
+        if (!isCause(cause) || !isCount(forcedWithinMs))
+            return undefined;
+        const say = (key, params) => renderMessage(msg(key, params), lang);
+        const lines = [];
+        const running = own(card, 'running');
+        const mine = own(card, 'own');
+        if (typeof running === 'string' && running.length > 0 && typeof mine === 'string' && mine.length > 0) {
+            lines.push(say('localEngine.card.versions', { running: displayUntrusted(running, { max: VERSION_DISPLAY_MAX }), own: displayUntrusted(mine, { max: VERSION_DISPLAY_MAX }) }));
+        }
+        const others = own(card, 'others');
+        const total = own(others, 'total');
+        const midTurn = own(others, 'midTurn');
+        if (isCount(total) && isCount(midTurn))
+            lines.push(say(total === 1 ? 'localEngine.card.others.one' : 'localEngine.card.others.other', { total, midTurn }));
+        else
+            lines.push(say('localEngine.card.others.unknown'));
+        const inflight = own(card, 'inflight');
+        if (isCount(inflight))
+            lines.push(say(inflight === 1 ? 'localEngine.card.inflight.one' : 'localEngine.card.inflight.other', { count: inflight }));
+        else
+            lines.push(say('localEngine.card.inflight.unknown'));
+        const bgLive = own(card, 'bgLive');
+        if (isCount(bgLive))
+            lines.push(say(bgLive === 1 ? 'localEngine.card.background.one' : 'localEngine.card.background.other', { count: bgLive }));
+        else
+            lines.push(say('localEngine.card.background.unknown'));
+        if (isCount(inflight) && inflight > 0 && isCount(bgLive) && bgLive > 0)
+            lines.push(say('localEngine.card.overlap'));
+        const unknown = own(card, 'unknown');
+        if (Array.isArray(unknown) && unknown.includes('self'))
+            lines.push(say('localEngine.card.selfUnknown'));
+        lines.push(say('localEngine.card.parked'));
+        return Object.freeze({
+            title: say(TITLE_KEYS[cause]),
+            lines: Object.freeze(lines),
+            force: say('localEngine.card.force', { seconds: Math.ceil(forcedWithinMs / 1000) }),
+            wait: say('localEngine.card.wait'),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/localEngineTiming.d.ts

@@ -0,0 +1,8 @@
+export declare const LOCAL_ENGINE_TIMING: Readonly<{
+    unansweredWaitMs: 60000;
+    prepareTimeoutMs: 10000;
+    stopProbeTimeoutMs: 4000;
+    crashWindowMs: 300000;
+    crashMaxDeaths: 3;
+    cooldownMs: readonly [60000, 120000, 240000, 480000, 600000, 600000];
+}>;

package/dist/localEngineTiming.js

@@ -0,0 +1,8 @@
+export const LOCAL_ENGINE_TIMING = Object.freeze({
+    unansweredWaitMs: 60000,
+    prepareTimeoutMs: 10000,
+    stopProbeTimeoutMs: 4000,
+    crashWindowMs: 300000,
+    crashMaxDeaths: 3,
+    cooldownMs: Object.freeze([60000, 120000, 240000, 480000, 600000, 600000]),
+});

package/dist/mcpReconnect.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { ownDataField } from './ownKey.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
+import { inSlotReadOf, inValueOf } from './wireFailureShape.js';
 import { readMcpAuthorization } from './mcpLiveness.js';
 export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
 export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
@@ -82,8 +83,11 @@ export function projectMcpReconnectResult(body) {
         added,
         removed,
     };
-    if ('toolNames' in body && body.toolNames !== undefined) {
-        const toolNames = stringList(body.toolNames);
+    const names = inValueOf(body, 'toolNames');
+    if (names.state === 'unproven')
+        return undefined;
+    if (names.state === 'present' && names.value !== undefined) {
+        const toolNames = stringList(names.value);
         if (toolNames === undefined)
             return undefined;
         view.toolNames = toolNames;
@@ -93,8 +97,11 @@ export function projectMcpReconnectResult(body) {
     const status = projectStatus(body.status);
     if (status !== undefined)
         view.status = status;
-    if ('listingIncomplete' in body && body.listingIncomplete !== undefined) {
-        const li = projectListingIncomplete(body.listingIncomplete);
+    const incomplete = inValueOf(body, 'listingIncomplete');
+    if (incomplete.state === 'unproven')
+        return undefined;
+    if (incomplete.state === 'present' && incomplete.value !== undefined) {
+        const li = projectListingIncomplete(incomplete.value);
         if (li === undefined)
             return undefined;
         view.listingIncomplete = li;
@@ -116,7 +123,7 @@ function unsettledVerdict(carrier) {
 }
 function isUnsettledBody(raw) {
     try {
-        return isRecord(raw) && !('outcome' in raw) && raw.errorCode === UNSETTLED_CODE;
+        return isRecord(raw) && inSlotReadOf(raw, 'outcome').state === 'absent' && raw.errorCode === UNSETTLED_CODE;
     }
     catch {
         return false;

package/dist/mcpWireCaps.js

@@ -329,7 +329,7 @@ function dropNotice(name, reason, problem, opts, path, transportKind) {
                     : reason === 'elicitation_invalid'
                         ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
                         : reason === 'allow_tools_invalid'
-                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: problem ?? '' })
                             : reason === 'identity_headers_both_set'
                                 ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
                                 : reason === 'transport_invalid'
@@ -448,6 +448,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.144.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.147.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/memoryEntriesWire.d.ts

@@ -61,7 +61,7 @@ export interface MemoryEraseConflictRow {
     id: string;
     reason: string;
 }
-declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
+declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "clearanceCustody", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
 export type MemoryEraseCarrierClass = (typeof MEMORY_ERASE_CARRIER_CLASSES)[number];
 export type MemoryEraseCarrierReading = {
     removed: number;

package/dist/memoryEntriesWire.js

@@ -174,6 +174,7 @@ const MEMORY_ERASE_CARRIER_CLASSES = Object.freeze([
     'shadow',
     'indexLine',
     'quarantineCopy',
+    'clearanceCustody',
     'planArchive',
     'planWorkbook',
     'evidenceBinding',
@@ -237,6 +238,10 @@ function eraseResidualsOf(o, lane) {
             return null;
         const carriers = {};
         for (const cls of MEMORY_ERASE_CARRIER_CLASSES) {
+            if (!Object.hasOwn(rawCarriers, cls)) {
+                carriers[cls] = { unverified: true };
+                continue;
+            }
             const answer = carrierAnswerOf(readThrownSlot(rawCarriers, cls, 'data'));
             if (answer === null)
                 return null;

package/dist/model/catalogDefault.d.ts

@@ -1,4 +1,6 @@
 import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL, type SETTINGS_DEFAULT_ROLE_TIER_LADDER } from '../generated/settingsSchemaFns.js';
+import { SETTINGS_MODEL_PLANE_REFUSAL_CODES } from '../generated/settingsSchemaTables.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
 export type CatalogDefaultModelsInput = Parameters<typeof SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL>[0];
 export type CatalogDefaultSource = 'roles.default' | 'fallback' | `tierGroup.${(typeof SETTINGS_DEFAULT_ROLE_TIER_LADDER)[number]}`;
 export interface CatalogDefaultDangling {
@@ -22,3 +24,26 @@ export interface CatalogDefaultSelect {
 }
 export type CatalogDefaultModel = CatalogDefaultNamed | CatalogDefaultSelect;
 export declare function resolveCatalogDefaultModel(models: CatalogDefaultModelsInput, has: (name: string) => boolean, fallback: string): CatalogDefaultModel;
+export type CatalogDefaultRefusalCode = Extract<(typeof SETTINGS_MODEL_PLANE_REFUSAL_CODES)[number], 'config.default_model_missing'>;
+export interface CatalogDefaultModelVerdictInput {
+    readonly models: CatalogDefaultModelsInput;
+    readonly has: (name: string) => boolean;
+    readonly fallback: string;
+    readonly face: object;
+}
+export interface CatalogDefaultResolvable {
+    readonly ok: true;
+    readonly default: CatalogDefaultModel;
+}
+export interface CatalogDefaultRefused {
+    readonly ok: false;
+    readonly code: CatalogDefaultRefusalCode;
+    readonly default: CatalogDefaultModel;
+    readonly detail: {
+        readonly cause: string;
+        readonly role: string;
+    };
+}
+export type CatalogDefaultModelVerdict = CatalogDefaultResolvable | CatalogDefaultRefused;
+export declare function catalogDefaultModelVerdict(input: CatalogDefaultModelVerdictInput): CatalogDefaultModelVerdict | undefined;
+export declare function catalogDefaultRefusalContent(verdict: CatalogDefaultModelVerdict, lang?: UiLanguage): string | undefined;

package/dist/model/catalogDefault.js

@@ -1,4 +1,48 @@
 import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL } from '../generated/settingsSchemaFns.js';
+import { modelFaceResolvable } from '../coreValuePorts.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { displayUntrusted } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export function resolveCatalogDefaultModel(models, has, fallback) {
     return SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL(models, has, fallback);
 }
+const CATALOG_DEFAULT_REFUSAL_CODE = 'config.default_model_missing';
+export function catalogDefaultModelVerdict(input) {
+    const { models, has, fallback, face } = input;
+    const chain = resolveCatalogDefaultModel(models, has, fallback);
+    const verdict = modelFaceResolvable(face, { spec: { modelRole: 'default' } });
+    if (verdict === undefined || typeof verdict !== 'object' || verdict === null)
+        return undefined;
+    const okSlot = slotReadOf(verdict, 'ok');
+    if (okSlot.presence !== 'present')
+        return undefined;
+    if (okSlot.value === true)
+        return Object.freeze({ ok: true, default: chain });
+    if (okSlot.value !== false)
+        return undefined;
+    const codeSlot = slotReadOf(verdict, 'code');
+    const roleSlot = slotReadOf(verdict, 'role');
+    const code = codeSlot.presence === 'present' ? codeSlot.value : undefined;
+    const role = roleSlot.presence === 'present' ? roleSlot.value : undefined;
+    if (typeof code !== 'string' || code.length === 0 || typeof role !== 'string' || role.length === 0)
+        return undefined;
+    return Object.freeze({
+        ok: false,
+        code: CATALOG_DEFAULT_REFUSAL_CODE,
+        default: chain,
+        detail: Object.freeze({ cause: code, role }),
+    });
+}
+export function catalogDefaultRefusalContent(verdict, lang) {
+    if (typeof verdict !== 'object' || verdict === null || verdict.ok !== false)
+        return undefined;
+    const d = verdict.default;
+    if (typeof d !== 'object' || d === null)
+        return undefined;
+    if (d.kind === 'named' && typeof d.name === 'string') {
+        return renderMessage(msg('model.catalogDefault.refused.named', { name: displayUntrusted(d.name, { max: 64 }) }), lang);
+    }
+    if (d.kind === 'select')
+        return renderMessage(msg('model.catalogDefault.refused.select'), lang);
+    return undefined;
+}

package/dist/noticePresentation.d.ts

@@ -6,7 +6,9 @@ export interface CutForDisplayResult {
     readonly shown: string;
     readonly truncated: boolean;
 }
+export declare function pairSafeCut(text: string, cut: number): number;
 export declare function cutForDisplay(text: string, budget: number, opts?: CutForDisplayOptions): CutForDisplayResult;
+export declare function elideMiddleForDisplay(text: string, budget: number): string;
 export type NoticePresentationAudience = 'user' | 'operator' | 'unknown';
 export type NoticeOutlet = 'present' | 'absent' | 'unknown';
 export type NoticeOccurrence = {