@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/skillOverrideChain.js

@@ -0,0 +1,378 @@
+import { SETTINGS_IS_RESERVED_MEMBER_NAME } from './generated/settingsSchemaFns.js';
+import { readOwnDataValue } from './ownKey.js';
+export const SKILL_OVERRIDE_STATES = Object.freeze(['on', 'name-only', 'user-invocable-only', 'off']);
+export const SKILL_ORIGINS = Object.freeze(['skills', 'synced', 'commands', 'mcp', 'plugin', 'builtin', 'bundled']);
+export const SKILL_OVERRIDE_LAYERS = Object.freeze(['policySettings', 'flagSettings', 'localSettings', 'projectSettings', 'userSettings']);
+export const SKILL_OVERRIDE_DECIDERS = Object.freeze([...SKILL_OVERRIDE_LAYERS, 'session', 'default', 'plugin', 'builtin_clamp', 'hidden_behind_plugin']);
+export const SKILL_OVERRIDE_LOCK_SOURCES = Object.freeze(['policy', 'flag', 'plugin', 'skill-author', 'reserved-name']);
+const MANAGED = ['policySettings', 'flagSettings'];
+const PLAIN = ['localSettings', 'projectSettings', 'userSettings'];
+const MERGED = ['policySettings', 'flagSettings', 'localSettings', 'projectSettings', 'userSettings'];
+const RANK = { on: 0, 'name-only': 1, 'user-invocable-only': 2, off: 3 };
+const LIST_BUDGET = 4096;
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+const isState = (v) => typeof v === 'string' && SKILL_OVERRIDE_STATES.some((w) => w === v);
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function stringsOf(v) {
+    const out = [];
+    if (!Array.isArray(v))
+        return out;
+    let n;
+    try {
+        n = own(v, 'length');
+    }
+    catch {
+        return out;
+    }
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0 || n > LIST_BUDGET)
+        return out;
+    for (let i = 0; i < n; i++) {
+        const s = own(v, String(i));
+        if (typeof s === 'string' && s !== '')
+            out.push(s);
+    }
+    return out;
+}
+export function shapeSkillSubject(v) {
+    if (!isRecord(v))
+        return undefined;
+    const name = own(v, 'name');
+    const originRaw = own(v, 'origin');
+    const origin = SKILL_ORIGINS.find((w) => w === originRaw);
+    if (typeof name !== 'string' || name === '' || origin === undefined)
+        return undefined;
+    const unq = own(v, 'unqualifiedName');
+    const synced = [];
+    const rawSynced = own(v, 'syncedNames');
+    if (Array.isArray(rawSynced)) {
+        const n = own(rawSynced, 'length');
+        if (typeof n === 'number' && Number.isSafeInteger(n) && n >= 0 && n <= LIST_BUDGET) {
+            for (let i = 0; i < n; i++) {
+                const e = own(rawSynced, String(i));
+                const sn = own(e, 'name');
+                const sb = own(e, 'bare');
+                if (typeof sn === 'string' && sn !== '' && typeof sb === 'string' && sb !== '')
+                    synced.push(Object.freeze({ name: sn, bare: sb }));
+            }
+        }
+    }
+    return Object.freeze({
+        name,
+        origin,
+        unqualifiedName: typeof unq === 'string' && unq !== '' ? unq : undefined,
+        bareNameReserved: own(v, 'bareNameReserved') === true,
+        aliases: Object.freeze(stringsOf(own(v, 'aliases'))),
+        mcpLabels: Object.freeze(stringsOf(own(v, 'mcpLabels')).filter((s) => s.includes(':'))),
+        reservedLabels: Object.freeze(stringsOf(own(v, 'reservedLabels'))),
+        syncedNames: Object.freeze(synced),
+        followsSyncedSkillState: own(v, 'followsSyncedSkillState') === true,
+        disableModelInvocation: own(v, 'disableModelInvocation') === true,
+        hiddenBehindPlugin: own(v, 'hiddenBehindPlugin') === true,
+    });
+}
+function overridesOf(doc) {
+    const ov = own(doc, 'skillOverrides');
+    return isRecord(ov) ? ov : undefined;
+}
+export function shapeSkillLayers(v) {
+    const docs = {};
+    for (const l of SKILL_OVERRIDE_LAYERS)
+        docs[l] = overridesOf(own(v, l));
+    const disabled = new Set(stringsOf(own(v, 'disabledSources')));
+    const session = own(v, 'session');
+    const enabled = (layer) => layer === 'policySettings' || layer === 'flagSettings' || !disabled.has(layer);
+    let fromSettings = false;
+    for (const l of MERGED) {
+        if (!enabled(l))
+            continue;
+        const b = own(own(v, l), 'disableBundledSkills');
+        if (typeof b === 'boolean') {
+            fromSettings = b;
+            break;
+        }
+    }
+    return Object.freeze({
+        docs: Object.freeze(docs),
+        session: isRecord(session) ? session : undefined,
+        enabled,
+        bundledDisabled: fromSettings || own(v, 'bundledSkillsDisabledByEnv') === true,
+    });
+}
+function at(ov, key) {
+    if (ov === undefined || key === undefined)
+        return undefined;
+    const w = own(ov, key);
+    return isState(w) ? w : undefined;
+}
+const hitAt = (ov, key, by) => {
+    const w = at(ov, key);
+    return w === undefined ? undefined : { value: w, by };
+};
+function stricter(a, b) {
+    if (a === undefined)
+        return b;
+    return b !== undefined && RANK[b.value] > RANK[a.value] ? b : a;
+}
+function strictestIn(ov, names, by) {
+    let r;
+    for (const n of names) {
+        const w = at(ov, n);
+        if (w !== undefined && (r === undefined || RANK[w] > RANK[r.value]))
+            r = { value: w, by };
+    }
+    return r;
+}
+export function bareNameOf(s) {
+    if (s.unqualifiedName === undefined)
+        return undefined;
+    if (s.origin !== 'synced')
+        return s.unqualifiedName;
+    return s.bareNameReserved ? undefined : s.unqualifiedName;
+}
+const freeLabels = (s) => s.mcpLabels.filter((l) => !s.reservedLabels.includes(l));
+function aliasNamesOf(s) {
+    return [...s.aliases, ...(s.unqualifiedName !== undefined ? [s.unqualifiedName] : []), ...freeLabels(s)];
+}
+export function secondaryNamesOf(s) {
+    const bare = bareNameOf(s);
+    return [...(bare !== undefined ? [bare] : []), ...(s.origin === 'mcp' ? freeLabels(s) : [])];
+}
+function reservedTighten(ov, s, by) {
+    const r = strictestIn(ov, s.reservedLabels, by);
+    return r === undefined || r.value === 'on' ? undefined : r;
+}
+function mergedAt(L, key) {
+    for (const l of MERGED) {
+        if (!L.enabled(l))
+            continue;
+        const h = hitAt(L.docs[l], key, l);
+        if (h !== undefined)
+            return h;
+    }
+    return undefined;
+}
+function viewThenSession(L, names) {
+    for (const n of names) {
+        const h = mergedAt(L, n);
+        if (h !== undefined)
+            return h;
+    }
+    for (const n of names) {
+        const h = hitAt(L.session, n, 'session');
+        if (h !== undefined)
+            return h;
+    }
+    return undefined;
+}
+function managedOnly(L, names) {
+    for (const n of names)
+        for (const l of MANAGED) {
+            const h = hitAt(L.docs[l], n, l);
+            if (h !== undefined)
+                return h;
+        }
+    return undefined;
+}
+function mcpChain(L, s, rest) {
+    const names = [s.name, ...rest];
+    let m;
+    let tight;
+    for (const l of MANAGED) {
+        m = stricter(m, strictestIn(L.docs[l], names, l));
+        tight = stricter(tight, reservedTighten(L.docs[l], s, l));
+    }
+    if (m !== undefined)
+        return stricter(m, tight);
+    for (const l of PLAIN) {
+        if (!L.enabled(l))
+            continue;
+        const b = strictestIn(L.docs[l], names, l);
+        if (b !== undefined)
+            return stricter(b, tight);
+    }
+    return stricter(strictestIn(L.session, names, 'session'), tight);
+}
+function overrideChain(L, s, mode) {
+    const rest = secondaryNamesOf(s);
+    if (s.origin === 'mcp')
+        return mcpChain(L, s, rest);
+    let v = (mode === 'all' ? viewThenSession : managedOnly)(L, [s.name, ...rest]);
+    const aliases = aliasNamesOf(s);
+    if (aliases.length === 0)
+        return v;
+    for (const l of MANAGED) {
+        const ov = L.docs[l];
+        if (at(ov, s.name) !== undefined)
+            break;
+        const w = strictestIn(ov, aliases, l);
+        if (w !== undefined && (v === undefined || RANK[w.value] > RANK[v.value]))
+            v = w;
+        if (rest.some((d) => at(ov, d) !== undefined))
+            break;
+    }
+    return v;
+}
+function managedLock(L, s, mode) {
+    const aliases = aliasNamesOf(s);
+    let found;
+    for (const l of MANAGED) {
+        const ov = L.docs[l];
+        const b = s.origin === 'mcp'
+            ? stricter(strictestIn(ov, [s.name, ...aliases], l), reservedTighten(ov, s, l))?.value
+            : (at(ov, s.name) ?? strictestIn(ov, aliases, l)?.value ?? reservedTighten(ov, s, l)?.value);
+        if (b === undefined)
+            continue;
+        if (s.origin !== 'mcp') {
+            found = { value: b, source: l };
+            break;
+        }
+        if (found === undefined || RANK[b] > RANK[found.value])
+            found = { value: b, source: l };
+    }
+    if (found === undefined)
+        return undefined;
+    const chain = overrideChain(L, s, mode);
+    return chain !== undefined ? { value: chain.value, source: found.source, by: chain.by } : { value: found.value, source: found.source, by: found.source };
+}
+function pluginManaged(L, s) {
+    if (s.origin !== 'plugin')
+        return managedLock(L, s, 'all');
+    let n;
+    for (const sn of s.syncedNames) {
+        const h = Object.freeze({
+            ...EMPTY_SUBJECT,
+            name: sn.name,
+            origin: 'synced',
+            unqualifiedName: sn.bare,
+            bareNameReserved: !s.aliases.includes(sn.bare),
+        });
+        const y = managedLock(L, h, 'administrator');
+        if (y !== undefined && (n === undefined || RANK[y.value] > RANK[n.value]))
+            n = y;
+    }
+    return n;
+}
+const EMPTY_SUBJECT = Object.freeze({
+    name: '',
+    origin: 'skills',
+    unqualifiedName: undefined,
+    bareNameReserved: false,
+    aliases: Object.freeze([]),
+    mcpLabels: Object.freeze([]),
+    reservedLabels: Object.freeze([]),
+    syncedNames: Object.freeze([]),
+    followsSyncedSkillState: false,
+    disableModelInvocation: false,
+    hiddenBehindPlugin: false,
+});
+function pluginFollow(L, s) {
+    let r;
+    for (const sn of s.syncedNames) {
+        const y = viewThenSession(L, s.followsSyncedSkillState || s.aliases.includes(sn.bare) ? [sn.name, sn.bare] : [sn.name]);
+        if (s.followsSyncedSkillState || y?.value === 'user-invocable-only')
+            r = stricter(r, y);
+    }
+    return r;
+}
+const effective = (value, decidedBy) => Object.freeze({ value, decidedBy });
+export function effectiveOfShaped(L, s) {
+    if (s.hiddenBehindPlugin)
+        return effective('off', 'hidden_behind_plugin');
+    if (s.origin === 'plugin') {
+        const m = pluginManaged(L, s);
+        const v = stricter(m === undefined ? undefined : { value: m.value, by: m.by }, pluginFollow(L, s));
+        return v === undefined ? effective('on', 'default') : effective(v.value, v.by);
+    }
+    const r = overrideChain(L, s, 'all');
+    const value = r?.value ?? 'on';
+    if (s.origin === 'builtin' && L.bundledDisabled)
+        return value === 'off' ? effective('off', r?.by ?? 'default') : effective('user-invocable-only', 'builtin_clamp');
+    return effective(value, r?.by ?? 'default');
+}
+const locked = (value, source) => Object.freeze({ value, source });
+export function lockOfShaped(L, s) {
+    const n = pluginManaged(L, s);
+    if (n !== undefined) {
+        const t = s.origin === 'plugin' ? effectiveOfShaped(L, s).value : n.value;
+        return locked(t, t !== n.value ? 'plugin' : n.source === 'policySettings' ? 'policy' : 'flag');
+    }
+    if (SETTINGS_IS_RESERVED_MEMBER_NAME(s.name))
+        return locked(s.disableModelInvocation ? 'user-invocable-only' : 'on', 'reserved-name');
+    if (s.disableModelInvocation)
+        return locked('user-invocable-only', 'skill-author');
+    if (s.origin === 'plugin')
+        return locked(effectiveOfShaped(L, s).value, 'plugin');
+    return undefined;
+}
+export function skillOverrideEffectiveOf(layers, skill) {
+    try {
+        const s = shapeSkillSubject(skill);
+        if (s === undefined)
+            return undefined;
+        return effectiveOfShaped(shapeSkillLayers(layers), s);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function skillOverrideLockOf(layers, skill) {
+    try {
+        const s = shapeSkillSubject(skill);
+        if (s === undefined)
+            return locked('on', 'reserved-name');
+        return lockOfShaped(shapeSkillLayers(layers), s);
+    }
+    catch {
+        return locked('on', 'reserved-name');
+    }
+}
+export function ownValueIn(ov, s) {
+    return s.origin === 'mcp' ? strictestIn(ov, [s.name, ...secondaryNamesOf(s)], 'default')?.value : at(ov, s.name);
+}
+export function stateAt(ov, key) {
+    return at(ov, key);
+}
+export function lowerTierOf(L, s, target, skipTargetBare) {
+    const doc = (l) => ((l === 'localSettings' && target === 'localSettings') || L.enabled(l) ? L.docs[l] : undefined);
+    if (s.origin === 'mcp') {
+        if (target === 'userSettings')
+            return undefined;
+        const names = [s.name, ...secondaryNamesOf(s)];
+        for (const l of ['projectSettings', 'userSettings']) {
+            if (!L.enabled(l))
+                continue;
+            const m = strictestIn(L.docs[l], names, l);
+            if (m !== undefined)
+                return m.value;
+        }
+        return undefined;
+    }
+    const bare = bareNameOf(s);
+    const bareChain = () => {
+        if (bare === undefined)
+            return undefined;
+        for (const l of PLAIN) {
+            if (skipTargetBare && l === target)
+                continue;
+            const w = at(doc(l), bare);
+            if (w !== undefined)
+                return w;
+        }
+        return undefined;
+    };
+    if (target === 'userSettings')
+        return bareChain();
+    return at(doc('projectSettings'), s.name) ?? at(doc('userSettings'), s.name) ?? bareChain();
+}
+export function withLayerDoc(L, layer, doc) {
+    return Object.freeze({ ...L, docs: Object.freeze({ ...L.docs, [layer]: overridesOf(doc) }) });
+}

package/dist/skillsWireCaps.d.ts

@@ -1,5 +1,6 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import { type SkillToolListsReading } from './skillToolListsCapability.js';
+import { type SkillOverrideLayers, type SkillOverrideSubject } from './skillOverrideChain.js';
 export interface SkillCmdLike {
     type?: string;
     name?: string;
@@ -10,6 +11,7 @@ export interface SkillCmdLike {
     skillRoot?: string;
     allowedTools?: readonly string[];
     disallowedTools?: readonly string[];
+    skillOverrideSubject?: SkillOverrideSubject;
 }
 export declare function toCappedSpec(name: string, description: string, whenToUse: string, body: string): SkillSpec | null;
 export type SkillSpecOnWire = SkillSpec & {
@@ -19,6 +21,7 @@ export interface SkillSpecsOptions {
     toolsRunHere?: boolean;
     platform?: 'posix' | 'win32';
     skillToolLists?: SkillToolListsReading;
+    skillOverrides?: SkillOverrideLayers;
 }
 export declare function skillBaseDirOf(skillRoot: string | undefined, platform?: 'posix' | 'win32'): string | undefined;
 export type SkillToolListKey = 'allowedTools' | 'disallowedTools';

package/dist/skillsWireCaps.js

@@ -1,6 +1,7 @@
 import { skillToolListsAvailable } from './skillToolListsCapability.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { appendOwnElement } from './ownKey.js';
+import { skillOverrideEffectiveOf } from './skillOverrideChain.js';
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
     const c = body.trim();
@@ -11,6 +12,13 @@ export function toCappedSpec(name, description, whenToUse, body) {
         .join(' — ');
     return { name: n, description: desc, content: c };
 }
+const ORIGIN_OF_SOURCE = { plugin: 'plugin', builtin: 'builtin', bundled: 'bundled', mcp: 'mcp' };
+function overrideSubjectOf(cmd, name) {
+    if (cmd.skillOverrideSubject !== undefined)
+        return cmd.skillOverrideSubject;
+    const src = typeof cmd.source === 'string' && Object.hasOwn(ORIGIN_OF_SOURCE, cmd.source) ? ORIGIN_OF_SOURCE[cmd.source] : undefined;
+    return { name, origin: src ?? 'skills' };
+}
 export function skillBaseDirOf(skillRoot, platform = 'posix') {
     if (skillRoot === undefined || skillRoot.length === 0 || skillRoot.length > 4096)
         return undefined;
@@ -120,10 +128,17 @@ export function skillCommandsToSpecs(cmds, resolveBody, opts) {
     for (const cmd of cmds) {
         if (cmd.type !== 'prompt' || cmd.disableModelInvocation)
             continue;
+        let nameOnly = false;
+        if (opts?.skillOverrides !== undefined) {
+            const eff = skillOverrideEffectiveOf(opts.skillOverrides, overrideSubjectOf(cmd, (cmd.name ?? '').trim()));
+            if (eff === undefined || eff.value === 'off' || eff.value === 'user-invocable-only')
+                continue;
+            nameOnly = eff.value === 'name-only';
+        }
         const body = resolveBody(cmd);
         if (!body)
             continue;
-        const spec = toCappedSpec(cmd.name ?? '', cmd.description ?? '', cmd.whenToUse ?? '', body);
+        const spec = toCappedSpec(cmd.name ?? '', nameOnly ? '' : (cmd.description ?? ''), nameOnly ? '' : (cmd.whenToUse ?? ''), body);
         if (!spec || seen.has(spec.name))
             continue;
         seen.add(spec.name);

package/dist/sseIdleTriage.js

@@ -1,5 +1,6 @@
 import { hostEnv } from './hostEnv.js';
 import { SseIdleError, StreamEndedWithoutTerminalError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
+import { classifyHealthProbe } from './engineHealthProbeVerdict.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
 import { SDK_STREAM_ENDED_REASONS } from './generated/sdkFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
@@ -62,7 +63,7 @@ export function isStreamEndedWithoutTerminalError(err) {
     return reading.kind !== 'unknown' || reading.why !== 'not_this_class';
 }
 export async function probeEngineAlive(baseUrl) {
-    return (await sdkProbeHealth(baseUrl)).alive;
+    return classifyHealthProbe(await sdkProbeHealth(baseUrl))?.kind === 'answered_ok';
 }
 export async function* diagnoseSseIdleTear(inner, baseUrl, signal) {
     try {

package/dist/storeDurabilityWord.d.ts

@@ -0,0 +1,15 @@
+declare const STORE_DURABILITY_WORDS: readonly ["durable", "ephemeral", "unknown"];
+export type EngineHealthStoreDurability = (typeof STORE_DURABILITY_WORDS)[number];
+export type StoreDurabilityRead = {
+    readonly kind: 'word';
+    readonly durability: EngineHealthStoreDurability;
+} | {
+    readonly kind: 'unrecognized';
+    readonly word: string;
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function readStoreDurability(section: object): StoreDurabilityRead;
+export {};

package/dist/storeDurabilityWord.js

@@ -0,0 +1,18 @@
+import { ownDataField } from './ownKey.js';
+const STORE_DURABILITY_WORDS = ['durable', 'ephemeral', 'unknown'];
+export function readStoreDurability(section) {
+    try {
+        const raw = ownDataField(section, 'durability');
+        if (raw === undefined)
+            return Object.freeze({ kind: 'absent' });
+        if (typeof raw !== 'string' || raw === '')
+            return Object.freeze({ kind: 'unreadable' });
+        for (const w of STORE_DURABILITY_WORDS)
+            if (raw === w)
+                return Object.freeze({ kind: 'word', durability: w });
+        return Object.freeze({ kind: 'unrecognized', word: raw });
+    }
+    catch {
+        return Object.freeze({ kind: 'unreadable' });
+    }
+}

package/dist/storePostureCapability.d.ts

@@ -1,8 +1,12 @@
 import { type SqlEngineCapabilityView } from './sqlEngineCapability.js';
+import { type EngineHealthStoreDurability } from './storeDurabilityWord.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface StorePostureView {
     declared: string;
     backend: string;
-    durable: boolean;
+    durable?: boolean;
+    durability?: EngineHealthStoreDurability;
+    unrecognizedDurability?: string;
     degradedReason?: string;
     sql?: SqlEngineCapabilityView;
 }
@@ -19,5 +23,5 @@ export type StorePostureReading = {
 export declare function projectStorePostureCapability(caps: unknown): StorePostureReading | undefined;
 export declare function observedStorePosture(baseUrl?: string | undefined): StorePostureReading;
 export declare function storePersistence(reading: StorePostureReading): 'durable' | 'not_durable' | 'unknown';
-export declare function storePostureHeadWord(reading: StorePostureReading): string | undefined;
-export declare function storePostureDoctorDetail(reading: StorePostureReading): string;
+export declare function storePostureHeadWord(reading: StorePostureReading, lang?: UiLanguage): string | undefined;
+export declare function storePostureDoctorDetail(reading: StorePostureReading, lang?: UiLanguage): string;

package/dist/storePostureCapability.js

@@ -3,6 +3,8 @@ import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
+import { readStoreDurability } from './storeDurabilityWord.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 export function projectStorePostureCapability(caps) {
     try {
@@ -21,8 +23,8 @@ function projectStorePostureOf(caps) {
     const store = seat.store;
     const declared = ownDataField(store, 'declared');
     const backend = ownDataField(store, 'backend');
-    const durable = ownDataField(store, 'durable');
-    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+    const durability = durabilityOf(store, 'wire');
+    if (!nonEmpty(declared) || !nonEmpty(backend) || durability.kind === 'malformed')
         return undefined;
     const reason = ownDataField(store, 'degradedReason');
     if (reason !== undefined && !nonEmpty(reason))
@@ -35,12 +37,44 @@ function projectStorePostureOf(caps) {
         view: {
             declared,
             backend,
-            durable,
+            ...(durability.kind === 'legacy' ? { durable: durability.durable } : {}),
+            ...(durability.kind === 'word' ? { durability: durability.durability } : {}),
+            ...(durability.kind === 'unrecognized' ? { unrecognizedDurability: durability.word } : {}),
             ...(nonEmpty(reason) ? { degradedReason: reason } : {}),
             ...(sqlReading.kind === 'present' ? { sql: sqlReading.view } : {}),
         },
     };
 }
+const MALFORMED_DURABILITY = Object.freeze({ kind: 'malformed' });
+function durabilityOf(section, side) {
+    try {
+        const word = readStoreDurability(section);
+        const durable = ownDataField(section, 'durable');
+        const unrecognized = side === 'view' ? ownDataField(section, 'unrecognizedDurability') : undefined;
+        const present = (word.kind === 'absent' ? 0 : 1) + (durable === undefined ? 0 : 1) + (unrecognized === undefined ? 0 : 1);
+        if (present !== 1)
+            return MALFORMED_DURABILITY;
+        if (word.kind === 'word')
+            return { kind: 'word', durability: word.durability };
+        if (word.kind === 'unrecognized')
+            return { kind: 'unrecognized', word: word.word };
+        if (typeof durable === 'boolean')
+            return { kind: 'legacy', durable };
+        if (nonEmpty(unrecognized))
+            return { kind: 'unrecognized', word: unrecognized };
+        return MALFORMED_DURABILITY;
+    }
+    catch {
+        return MALFORMED_DURABILITY;
+    }
+}
+function persistenceOf(d) {
+    if (d.kind === 'legacy')
+        return d.durable ? 'durable' : 'not_durable';
+    if (d.kind !== 'word')
+        return 'unknown';
+    return d.durability === 'durable' ? 'durable' : d.durability === 'ephemeral' ? 'not_durable' : 'unknown';
+}
 const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
@@ -70,58 +104,54 @@ export function storePersistence(reading) {
     const r = presentView(reading);
     if (r?.kind !== 'present')
         return 'unknown';
-    let durable;
-    try {
-        durable = r.view.durable;
-    }
-    catch {
-        return 'unknown';
-    }
-    return durable === true ? 'durable' : durable === false ? 'not_durable' : 'unknown';
+    return persistenceOf(durabilityOf(r.view, 'view'));
 }
-const STORE_NOT_DURABLE_HEAD = 'NOT durable';
-export function storePostureHeadWord(reading) {
-    return storePersistence(reading) === 'not_durable' ? STORE_NOT_DURABLE_HEAD : undefined;
+const notDurableHead = () => msg('notice.capability.storePosture.notDurableHead');
+export function storePostureHeadWord(reading, lang) {
+    return storePersistence(reading) === 'not_durable' ? renderMessage(notDurableHead(), lang) : undefined;
 }
 const WORD_DETAIL_MAX = 40;
 const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
-export function storePostureDoctorDetail(reading) {
-    const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
+export function storePostureDoctorDetail(reading, lang) {
+    const say = (ref) => renderMessage(ref, lang);
+    const unobserved = msg('notice.capability.storePosture.unobserved');
     const r = presentView(reading);
     if (r?.kind === 'unreadable')
-        return unreadableReadingDetail('store posture');
-    if (r?.kind === 'not_reported') {
-        return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
-    }
+        return unreadableReadingDetail(say(msg('notice.capability.subject.storePosture')), lang);
+    if (r?.kind === 'not_reported')
+        return say(msg('notice.capability.storePosture.notReported'));
     if (r?.kind !== 'present')
-        return unobserved;
+        return say(unobserved);
     let declared;
     let backend;
-    let durable;
     let reason;
     try {
         declared = r.view.declared;
         backend = r.view.backend;
-        durable = r.view.durable;
         reason = r.view.degradedReason;
     }
     catch {
-        return unobserved;
-    }
-    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
-        return unobserved;
-    const assembled = declared === backend ? `store ${word(backend)}` : `store declared ${word(declared)}, running on ${word(backend)}`;
-    if (durable) {
-        return `${assembled} — durable: this replica persists its state, so it survives a restart`;
+        return say(unobserved);
     }
-    const lost = `${STORE_NOT_DURABLE_HEAD}: this replica holds its state in memory and loses it on restart`;
+    const durability = durabilityOf(r.view, 'view');
+    if (!nonEmpty(declared) || !nonEmpty(backend) || durability.kind === 'malformed')
+        return say(unobserved);
+    const assembled = declared === backend
+        ? msg('notice.capability.storePosture.assembled', { backend: word(backend) })
+        : msg('notice.capability.storePosture.assembledDeclared', { declared: word(declared), backend: word(backend) });
+    if (durability.kind === 'unrecognized')
+        return say(msg('notice.capability.storePosture.unrecognized', { assembled, word: word(durability.word) }));
+    const persistence = persistenceOf(durability);
+    if (persistence === 'durable')
+        return say(msg('notice.capability.storePosture.durable', { assembled }));
+    if (persistence === 'unknown')
+        return say(msg('notice.capability.storePosture.unknown', { assembled }));
+    const line = msg(durability.kind === 'legacy' ? 'notice.capability.storePosture.memory' : 'notice.capability.storePosture.ephemeral', { assembled, head: notDurableHead() });
     if (!nonEmpty(reason))
-        return `${assembled} — ${lost}`;
-    if (reason === 'db_unreachable') {
-        return `${assembled} — ${lost} (degraded: the declared database could not be opened at start-up, so the engine fell back rather than refusing to start)`;
-    }
-    if (reason === 'local_unwritable') {
-        return `${assembled} — ${lost} (degraded: the default local file store could not be created — a read-only or full data directory is one possible cause, and this client cannot tell which applies)`;
-    }
-    return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
+        return say(line);
+    if (reason === 'db_unreachable')
+        return say(msg('notice.capability.storePosture.degraded.dbUnreachable', { line }));
+    if (reason === 'local_unwritable')
+        return say(msg('notice.capability.storePosture.degraded.localUnwritable', { line }));
+    return say(msg('notice.capability.storePosture.degraded.other', { line, reason: word(reason) }));
 }