@sema-agent/client-core 0.111.0 → 0.112.1

package/dist/localConfig/kernel.js

@@ -0,0 +1,597 @@
+import { SETTINGS_ROOT_DOCUMENT_UNREADABLE_REASONS } from '../generated/settingsSchemaTables.js';
+import { ownSnapshotRecord, ownSnapshotRecordFaithful, readOwnDataValue, appendOwnElement } from '../ownKey.js';
+import { capForDisplay } from '../fleetTaskDesc.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { isWritableLocalConfigDocument, localConfigDocumentOf } from './documents.js';
+export const LOCAL_CONFIG_UNREADABLE_CAUSES = SETTINGS_ROOT_DOCUMENT_UNREADABLE_REASONS;
+export const LOCAL_CONFIG_REFUSALS = Object.freeze([
+    'invalid_request',
+    'scope_unreadable',
+    'scope_unwritable',
+    'untrusted_folder',
+    'policy_denied',
+    'not_found',
+    'already_exists',
+    'lock_busy',
+    'lock_failed',
+    'changed_during_write',
+    'write_failed',
+    'not_written',
+    'name_unusable',
+    'name_reserved',
+    'mcp_entry_invalid',
+    'ambiguous_scope',
+    'credentials_need_reentry',
+    'base_conflict',
+    'skill_locked_by_higher_layer',
+    'skill_managed_by_plugin',
+    'skill_locked_by_author',
+    'skill_name_unstorable',
+    'entry_in_use',
+    'credential_unpaired',
+    'env_catalog_present',
+    'probe_failed',
+    'probe_unverified',
+]);
+export const LOCAL_CONFIG_NOT_WRITTEN_CAUSES = Object.freeze(['lock_busy', 'lock_failed', 'changed_during_write', 'write_failed']);
+export const LOCAL_CONFIG_UNAVAILABLE_CAUSES = Object.freeze(['engine_is_remote', 'not_single_user', 'config_home_unpinned', 'domain_not_hosted']);
+export const LOCAL_CONFIG_UNKNOWN_CAUSES = Object.freeze(['commit_unconfirmed', 'report_unreadable']);
+export const LOCAL_CONFIG_APPLIES_ON = Object.freeze(['next_turn', 'engine_reload', 'next_engine_start']);
+export const LOCAL_CONFIG_RESIDUES = Object.freeze(['orphan_key_slot', 'legacy_tier_groups_left']);
+export const LOCAL_CONFIG_DISCLOSURE_KINDS = Object.freeze(['decided_by', 'shadowed_by', 'tier_group_overridden']);
+export const LOCAL_CONFIG_STEP_ROLES = Object.freeze(['prepare', 'effect', 'cleanup']);
+export const LOCAL_CONFIG_WRITE_PRECONDITIONS = Object.freeze([
+    'shared_path_lock',
+    'lock_loss_returned',
+    'writers_joined',
+    'shared_rank',
+    'global_state_migrated',
+    'targets_bound_by_host',
+    'write_route',
+]);
+const ENGINE_WORDS = ['local', 'cloud'];
+const ROUTE_WORDS = ['host', 'seat_proxy', 'bff_direct'];
+function own(v, key) {
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const blocked = (cause, missing = []) => Object.freeze({ ok: false, cause, missing: Object.freeze([...missing]) });
+const OPEN = Object.freeze({ ok: true });
+function sharedRankSetOf(v) {
+    const out = new Set();
+    if (!Array.isArray(v))
+        return out;
+    try {
+        for (let i = 0; i < v.length; i++) {
+            const name = own(v, String(i));
+            if (typeof name === 'string' && name !== '')
+                out.add(name);
+        }
+    }
+    catch {
+        return new Set();
+    }
+    return out;
+}
+export function localConfigAccess(facts, request) {
+    try {
+        if (!isRecord(facts))
+            return blocked('domain_not_hosted');
+        const engine = own(facts, 'engine');
+        if (engine === 'cloud')
+            return blocked('engine_is_remote');
+        if (!ENGINE_WORDS.some((w) => w === engine))
+            return blocked('domain_not_hosted');
+        if (own(facts, 'tenancy') !== 'single_user')
+            return blocked('not_single_user');
+        if (own(facts, 'configHomePinned') !== true)
+            return blocked('config_home_unpinned');
+        const route = own(facts, 'route');
+        if (!ROUTE_WORDS.some((w) => w === route))
+            return blocked('domain_not_hosted');
+        if (!isRecord(request))
+            return blocked('domain_not_hosted');
+        const access = own(request, 'access');
+        if (access !== 'read' && access !== 'write')
+            return blocked('domain_not_hosted');
+        const missing = new Set();
+        if (route !== 'host' && own(facts, 'targetsBoundByHost') !== true)
+            missing.add('targets_bound_by_host');
+        if (access === 'write') {
+            const docs = own(request, 'docs');
+            if (!Array.isArray(docs) || docs.length === 0)
+                return blocked('domain_not_hosted');
+            const names = [];
+            for (let i = 0; i < docs.length; i++) {
+                const name = own(docs, String(i));
+                if (!isWritableLocalConfigDocument(name))
+                    return blocked('domain_not_hosted');
+                names.push(name);
+            }
+            if (route === 'bff_direct')
+                missing.add('write_route');
+            if (own(facts, 'sharedPathLock') !== true)
+                missing.add('shared_path_lock');
+            if (own(facts, 'lockLossReturned') !== true)
+                missing.add('lock_loss_returned');
+            if (own(facts, 'writersJoined') !== true)
+                missing.add('writers_joined');
+            const shared = sharedRankSetOf(own(facts, 'sharedRanks'));
+            if (names.some((n) => !shared.has(localConfigDocumentOf(n)?.lockRank ?? '')))
+                missing.add('shared_rank');
+            if (names.includes('globalConfig') && own(facts, 'globalStateMigrated') !== true)
+                missing.add('global_state_migrated');
+        }
+        if (missing.size > 0)
+            return blocked('domain_not_hosted', LOCAL_CONFIG_WRITE_PRECONDITIONS.filter((p) => missing.has(p)));
+        return OPEN;
+    }
+    catch {
+        return blocked('domain_not_hosted');
+    }
+}
+const MAX_STEPS = 8;
+const DETAIL_MAX = 240;
+function docListOf(v, writable) {
+    if (v === undefined)
+        return [];
+    if (!Array.isArray(v) || v.length > 16)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < v.length; i++) {
+        const name = own(v, String(i));
+        const row = localConfigDocumentOf(name);
+        if (row === undefined || (writable && row.lockRank === null))
+            return undefined;
+        if (!out.includes(row.name))
+            out.push(row.name);
+    }
+    return out;
+}
+function shapeIntent(intent) {
+    if (!isRecord(intent))
+        return undefined;
+    const appliesOn = own(intent, 'appliesOn');
+    const when = LOCAL_CONFIG_APPLIES_ON.find((w) => w === appliesOn);
+    if (when === undefined)
+        return undefined;
+    const raw = own(intent, 'steps');
+    if (!Array.isArray(raw) || raw.length === 0 || raw.length > MAX_STEPS)
+        return undefined;
+    const steps = [];
+    let phase = 0;
+    for (let i = 0; i < raw.length; i++) {
+        const s = own(raw, String(i));
+        if (!isRecord(s))
+            return undefined;
+        const doc = own(s, 'doc');
+        if (!isWritableLocalConfigDocument(doc))
+            return undefined;
+        const role = LOCAL_CONFIG_STEP_ROLES.find((w) => w === own(s, 'role'));
+        if (role === undefined)
+            return undefined;
+        const prior = steps.filter((x) => x.doc === doc);
+        if (prior.length > 0 && !(role === 'cleanup' && prior.length === 1 && prior[0].role === 'prepare'))
+            return undefined;
+        const residueRaw = own(s, 'residue');
+        const residue = LOCAL_CONFIG_RESIDUES.find((w) => w === residueRaw);
+        if (role === 'effect' ? residueRaw !== undefined : residue === undefined)
+            return undefined;
+        if (role === 'prepare' && phase !== 0)
+            return undefined;
+        if (role === 'effect') {
+            if (phase !== 0)
+                return undefined;
+            phase = 1;
+        }
+        if (role === 'cleanup' && phase !== 1)
+            return undefined;
+        const extraLock = docListOf(own(s, 'lock'), true);
+        const snap = docListOf(own(s, 'snapshot'), false);
+        const plan = own(s, 'plan');
+        if (extraLock === undefined || snap === undefined || typeof plan !== 'function')
+            return undefined;
+        const lock = [doc, ...extraLock.filter((d) => d !== doc && isWritableLocalConfigDocument(d))];
+        steps.push({ doc, role, residue, lock: Object.freeze(lock), snapshot: Object.freeze(snap.filter((d) => !lock.some((l) => l === d))), plan: plan });
+    }
+    if (phase !== 1)
+        return undefined;
+    return { appliesOn: when, steps, docs: Object.freeze(steps.map((s) => s.doc)) };
+}
+const UNREADABLE_IO = Object.freeze({ status: 'unreadable', cause: 'io' });
+const ABSENT = Object.freeze({ status: 'absent' });
+const OUTSIDE_FENCE = Object.freeze({ status: 'outside_fence' });
+function readingOf(v) {
+    if (!isRecord(v))
+        return UNREADABLE_IO;
+    const status = own(v, 'status');
+    if (status === 'absent')
+        return ABSENT;
+    if (status === 'outside_fence')
+        return OUTSIDE_FENCE;
+    if (status === 'unreadable') {
+        const cause = LOCAL_CONFIG_UNREADABLE_CAUSES.find((w) => w === own(v, 'cause'));
+        return cause === undefined ? UNREADABLE_IO : Object.freeze({ status: 'unreadable', cause });
+    }
+    if (status === 'loaded') {
+        const revision = own(v, 'revision');
+        const rawDoc = own(v, 'doc');
+        if (typeof revision !== 'string' || revision === '' || !isRecord(rawDoc))
+            return UNREADABLE_IO;
+        const doc = ownSnapshotRecordFaithful(rawDoc);
+        return doc === undefined ? UNREADABLE_IO : Object.freeze({ status: 'loaded', doc: doc, revision });
+    }
+    return UNREADABLE_IO;
+}
+function filesOf(v, names) {
+    const out = {};
+    for (const name of names)
+        out[name] = readingOf(isRecord(v) ? own(v, name) : undefined);
+    return Object.freeze(out);
+}
+const refuseVerdict = (reason, detail) => ({ kind: 'refuse', reason, detail });
+function disclosuresOf(v) {
+    if (v === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(v) || v.length > 16)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < v.length; i++) {
+        const d = own(v, String(i));
+        if (!isRecord(d))
+            return undefined;
+        const kind = LOCAL_CONFIG_DISCLOSURE_KINDS.find((w) => w === own(d, 'kind'));
+        const layerRaw = own(d, 'layer');
+        const layer = layerRaw === undefined ? undefined : localConfigDocumentOf(layerRaw)?.name;
+        const detailRaw = own(d, 'detail');
+        if (kind === undefined || (layerRaw !== undefined && layer === undefined) || (detailRaw !== undefined && typeof detailRaw !== 'string'))
+            return undefined;
+        const detail = typeof detailRaw === 'string' && detailRaw !== '' ? capForDisplay(detailRaw, DETAIL_MAX) : undefined;
+        appendOwnElement(out, Object.freeze({ kind, ...(layer === undefined ? {} : { layer }), ...(detail === undefined ? {} : { detail }) }));
+    }
+    return Object.freeze(out);
+}
+function planVerdictOf(v) {
+    if (!isRecord(v))
+        return refuseVerdict('invalid_request');
+    const kind = own(v, 'kind');
+    const carryRaw = own(v, 'carry');
+    const carry = carryRaw === undefined ? undefined : isRecord(carryRaw) ? ownSnapshotRecordFaithful(carryRaw) : undefined;
+    if ((kind === 'write' || kind === 'unchanged') && carryRaw !== undefined && carry === undefined)
+        return refuseVerdict('invalid_request');
+    const disclosures = kind === 'write' || kind === 'unchanged' ? disclosuresOf(own(v, 'disclose')) : undefined;
+    if ((kind === 'write' || kind === 'unchanged') && disclosures === undefined)
+        return refuseVerdict('invalid_request');
+    if (kind === 'unchanged')
+        return { kind, carry, disclosures: disclosures ?? Object.freeze([]) };
+    if (kind === 'write') {
+        const rawNext = own(v, 'next');
+        const next = isRecord(rawNext) ? ownSnapshotRecordFaithful(rawNext) : undefined;
+        return next === undefined ? refuseVerdict('invalid_request') : { kind, next, carry, disclosures: disclosures ?? Object.freeze([]) };
+    }
+    if (kind === 'refuse') {
+        const reason = LOCAL_CONFIG_REFUSALS.find((w) => w === own(v, 'reason'));
+        const detail = own(v, 'detail');
+        if (reason === undefined)
+            return refuseVerdict('invalid_request');
+        return refuseVerdict(reason, typeof detail === 'string' && detail !== '' ? capForDisplay(detail, DETAIL_MAX) : undefined);
+    }
+    return refuseVerdict('invalid_request');
+}
+function sameJson(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameJson(x, b[i]));
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    return ka.every((k) => Object.hasOwn(b, k) && sameJson(a[k], b[k]));
+}
+function planStep(step, fresh, carried, mode) {
+    const target = fresh[step.doc];
+    if (target === undefined || target.status === 'unreadable')
+        return refuseVerdict('scope_unreadable');
+    if (target.status === 'outside_fence')
+        return refuseVerdict('scope_unwritable');
+    let raw;
+    try {
+        raw = step.plan(Object.freeze({ fresh, carried, mode }));
+    }
+    catch {
+        return refuseVerdict('invalid_request');
+    }
+    const verdict = planVerdictOf(raw);
+    if (verdict.kind === 'write' && target.status === 'loaded' && sameJson(target.doc, verdict.next))
+        return { kind: 'unchanged', carry: verdict.carry, disclosures: verdict.disclosures };
+    return verdict;
+}
+function addDisclosures(into, more) {
+    for (const d of more)
+        if (!into.some((x) => x.kind === d.kind && x.layer === d.layer && x.detail === d.detail))
+            appendOwnElement(into, d);
+}
+const disclosuresField = (list) => list.length === 0 ? {} : { disclosures: Object.freeze([...list]) };
+const mergeCarry = (carried, extra) => extra === undefined ? carried : (ownSnapshotRecord({ ...carried, ...extra }) ?? carried);
+function portMethod(store, name) {
+    if (typeof store !== 'object' || store === null)
+        return undefined;
+    try {
+        const m = store[name];
+        return typeof m === 'function' ? m : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runStep(store, transact, step, carried) {
+    const st = { calls: 0, handedOut: false, verdict: undefined };
+    const names = [...step.lock, ...step.snapshot];
+    const build = (freshRaw) => {
+        st.calls += 1;
+        if (st.calls > 1)
+            throw new Error('local config: build must be called exactly once per step');
+        const fresh = filesOf(freshRaw, names);
+        const verdict = planStep(step, fresh, carried, 'commit');
+        st.verdict = verdict;
+        if (verdict.kind !== 'write')
+            return undefined;
+        const target = fresh[step.doc];
+        st.handedOut = true;
+        return Object.freeze({ doc: step.doc, next: verdict.next, expectRevision: target !== undefined && target.status === 'loaded' ? target.revision : null });
+    };
+    let report;
+    let threw = false;
+    try {
+        report = await transact.call(store, Object.freeze({ lock: step.lock, snapshot: step.snapshot }), build);
+    }
+    catch {
+        threw = true;
+    }
+    const notCommittedCause = () => {
+        if (!isRecord(report) || !Object.hasOwn(report, 'notCommitted'))
+            return undefined;
+        return LOCAL_CONFIG_NOT_WRITTEN_CAUSES.find((w) => w === own(report, 'notCommitted')) ?? 'not_written';
+    };
+    const v = st.verdict;
+    if (st.handedOut) {
+        if (st.calls > 1)
+            return { kind: 'unknown', cause: 'report_unreadable' };
+        if (threw)
+            return { kind: 'unknown', cause: 'commit_unconfirmed' };
+        if (report === 'committed')
+            return v !== undefined && v.kind === 'write' ? { kind: 'committed', carry: v.carry, disclosures: v.disclosures } : { kind: 'unknown', cause: 'report_unreadable' };
+        const cause = notCommittedCause();
+        return cause !== undefined ? { kind: 'refused', reason: cause, detail: undefined } : { kind: 'unknown', cause: 'report_unreadable' };
+    }
+    if (v !== undefined && v.kind === 'refuse')
+        return { kind: 'refused', reason: v.reason, detail: v.detail };
+    if (v !== undefined && v.kind === 'unchanged')
+        return { kind: 'unchanged', carry: v.carry, disclosures: v.disclosures };
+    const cause = threw ? undefined : notCommittedCause();
+    return { kind: 'refused', reason: cause ?? 'not_written', detail: undefined };
+}
+const residueField = (list) => list.length === 0 ? {} : { residue: Object.freeze([...list]) };
+const refusedReceipt = (reason, detail, residue) => Object.freeze({ kind: 'refused', reason, ...(detail === undefined ? {} : { detail }), ...residueField(residue) });
+const unknownReceipt = (cause, residue) => Object.freeze({ kind: 'unknown', cause, ...residueField(residue) });
+const unavailableReceipt = (cause) => Object.freeze({ kind: 'unavailable', cause });
+export async function applyLocalConfigIntent(intent, store, facts) {
+    let portTouched = false;
+    const prepared = [];
+    try {
+        const shaped = shapeIntent(intent);
+        if (shaped === undefined)
+            return refusedReceipt('invalid_request', undefined, []);
+        const access = localConfigAccess(facts, { access: 'write', docs: shaped.docs });
+        if (!access.ok)
+            return unavailableReceipt(access.cause);
+        const transact = portMethod(store, 'transact');
+        if (transact === undefined)
+            return unavailableReceipt('domain_not_hosted');
+        let carried = Object.freeze({});
+        let changed = false;
+        const leftover = [];
+        const disclosed = [];
+        for (let i = 0; i < shaped.steps.length; i++) {
+            const step = shaped.steps[i];
+            portTouched = true;
+            const out = await runStep(store, transact, step, carried);
+            if (out.kind === 'committed' || out.kind === 'unchanged') {
+                if (out.kind === 'committed') {
+                    changed = true;
+                    if (step.role === 'prepare' && step.residue !== undefined)
+                        appendOwnElement(prepared, step.residue);
+                }
+                addDisclosures(disclosed, out.disclosures);
+                carried = mergeCarry(carried, out.carry);
+                continue;
+            }
+            if (step.role === 'cleanup') {
+                for (const rest of shaped.steps.slice(i))
+                    if (rest.residue !== undefined && !leftover.includes(rest.residue))
+                        appendOwnElement(leftover, rest.residue);
+                break;
+            }
+            if (out.kind === 'refused')
+                return refusedReceipt(out.reason, out.detail, prepared);
+            const unsure = step.role === 'prepare' && step.residue !== undefined && !prepared.includes(step.residue) ? [...prepared, step.residue] : prepared;
+            return unknownReceipt(out.cause, unsure);
+        }
+        return Object.freeze({ kind: 'applied', appliesOn: shaped.appliesOn, changed, ...residueField(leftover), ...disclosuresField(disclosed) });
+    }
+    catch {
+        return portTouched ? unknownReceipt('commit_unconfirmed', prepared) : refusedReceipt('invalid_request', undefined, []);
+    }
+}
+export async function previewLocalConfigIntent(intent, store, facts) {
+    try {
+        const shaped = shapeIntent(intent);
+        if (shaped === undefined)
+            return Object.freeze({ kind: 'refused', reason: 'invalid_request' });
+        const access = localConfigAccess(facts, { access: 'write', docs: shaped.docs });
+        if (!access.ok)
+            return unavailableReceipt(access.cause);
+        const read = portMethod(store, 'read');
+        if (read === undefined)
+            return unavailableReceipt('domain_not_hosted');
+        const names = [];
+        for (const s of shaped.steps)
+            for (const d of [...s.lock, ...s.snapshot])
+                if (!names.includes(d))
+                    names.push(d);
+        let raw;
+        try {
+            raw = await read.call(store, Object.freeze([...names]));
+        }
+        catch {
+            return Object.freeze({ kind: 'refused', reason: 'scope_unreadable' });
+        }
+        const fresh = filesOf(raw, names);
+        let carried = Object.freeze({});
+        const writes = [];
+        const disclosed = [];
+        for (const step of shaped.steps) {
+            const v = planStep(step, fresh, carried, 'preview');
+            if (v.kind === 'refuse')
+                return Object.freeze({ kind: 'refused', reason: v.reason, ...(v.detail === undefined ? {} : { detail: v.detail }) });
+            if (v.kind === 'write')
+                writes.push(step.doc);
+            addDisclosures(disclosed, v.disclosures);
+            carried = mergeCarry(carried, v.carry);
+        }
+        return Object.freeze({ kind: 'preview', appliesOn: shaped.appliesOn, changed: writes.length > 0, writes: Object.freeze(writes), ...disclosuresField(disclosed) });
+    }
+    catch {
+        return Object.freeze({ kind: 'refused', reason: 'invalid_request' });
+    }
+}
+const REFUSAL_KEYS = {
+    invalid_request: 'config.localConfig.refused.invalidRequest',
+    scope_unreadable: 'config.localConfig.refused.scopeUnreadable',
+    scope_unwritable: 'config.localConfig.refused.scopeUnwritable',
+    untrusted_folder: 'config.localConfig.refused.untrustedFolder',
+    policy_denied: 'config.localConfig.refused.policyDenied',
+    not_found: 'config.localConfig.refused.notFound',
+    already_exists: 'config.localConfig.refused.alreadyExists',
+    lock_busy: 'config.localConfig.refused.lockBusy',
+    lock_failed: 'config.localConfig.refused.lockFailed',
+    changed_during_write: 'config.localConfig.refused.changedDuringWrite',
+    write_failed: 'config.localConfig.refused.writeFailed',
+    not_written: 'config.localConfig.refused.notWritten',
+    name_unusable: 'config.localConfig.refused.nameUnusable',
+    name_reserved: 'config.localConfig.refused.nameReserved',
+    mcp_entry_invalid: 'config.localConfig.refused.mcpEntryInvalid',
+    ambiguous_scope: 'config.localConfig.refused.ambiguousScope',
+    credentials_need_reentry: 'config.localConfig.refused.credentialsNeedReentry',
+    base_conflict: 'config.localConfig.refused.baseConflict',
+    skill_locked_by_higher_layer: 'config.localConfig.refused.skillLockedByHigherLayer',
+    skill_managed_by_plugin: 'config.localConfig.refused.skillManagedByPlugin',
+    skill_locked_by_author: 'config.localConfig.refused.skillLockedByAuthor',
+    skill_name_unstorable: 'config.localConfig.refused.skillNameUnstorable',
+    entry_in_use: 'config.localConfig.refused.entryInUse',
+    credential_unpaired: 'config.localConfig.refused.credentialUnpaired',
+    env_catalog_present: 'config.localConfig.refused.envCatalogPresent',
+    probe_failed: 'config.localConfig.refused.probeFailed',
+    probe_unverified: 'config.localConfig.refused.probeUnverified',
+};
+const UNAVAILABLE_KEYS = {
+    engine_is_remote: 'config.localConfig.unavailable.engineIsRemote',
+    not_single_user: 'config.localConfig.unavailable.notSingleUser',
+    config_home_unpinned: 'config.localConfig.unavailable.configHomeUnpinned',
+    domain_not_hosted: 'config.localConfig.unavailable.domainNotHosted',
+};
+const UNKNOWN_KEYS = {
+    commit_unconfirmed: 'config.localConfig.unknown.commitUnconfirmed',
+    report_unreadable: 'config.localConfig.unknown.reportUnreadable',
+};
+const APPLIED_KEYS = {
+    next_turn: 'config.localConfig.applied.nextTurn',
+    engine_reload: 'config.localConfig.applied.engineReload',
+    next_engine_start: 'config.localConfig.applied.nextEngineStart',
+};
+const PREVIEW_KEYS = {
+    next_turn: 'config.localConfig.preview.nextTurn',
+    engine_reload: 'config.localConfig.preview.engineReload',
+    next_engine_start: 'config.localConfig.preview.nextEngineStart',
+};
+const RESIDUE_KEYS = {
+    orphan_key_slot: 'config.localConfig.residue.orphanKeySlot',
+    legacy_tier_groups_left: 'config.localConfig.residue.legacyTierGroupsLeft',
+};
+const DISCLOSURE_KEYS = {
+    decided_by: 'config.localConfig.disclosure.decidedBy',
+    shadowed_by: 'config.localConfig.disclosure.shadowed',
+    tier_group_overridden: 'config.localConfig.disclosure.tierGroupOverridden',
+};
+const DISCLOSURE_NAMED_KEYS = {
+    tier_group_overridden: 'config.localConfig.disclosure.tierGroupOverriddenNamed',
+};
+const LAYER_KEYS = {
+    userSettings: 'config.localConfig.layer.userSettings',
+    projectSettings: 'config.localConfig.layer.projectSettings',
+    localSettings: 'config.localConfig.layer.localSettings',
+    globalConfig: 'config.localConfig.layer.globalConfig',
+    projectMcp: 'config.localConfig.layer.projectMcp',
+    models: 'config.localConfig.layer.models',
+    deploymentMcp: 'config.localConfig.layer.deploymentMcp',
+    policySettings: 'config.localConfig.layer.policySettings',
+};
+function pick(table, word, fallback) {
+    return typeof word === 'string' && Object.hasOwn(table, word) ? table[word] : fallback;
+}
+export function localConfigReceiptSentence(receipt, lang) {
+    let key = REFUSAL_KEYS.not_written;
+    try {
+        if (isRecord(receipt)) {
+            const kind = own(receipt, 'kind');
+            if (kind === 'applied' || kind === 'preview') {
+                const changed = own(receipt, 'changed');
+                key = changed === false ? (kind === 'applied' ? 'config.localConfig.applied.unchanged' : 'config.localConfig.preview.unchanged') : pick(kind === 'applied' ? APPLIED_KEYS : PREVIEW_KEYS, own(receipt, 'appliesOn'), kind === 'applied' ? APPLIED_KEYS.next_turn : PREVIEW_KEYS.next_turn);
+            }
+            else if (kind === 'refused')
+                key = pick(REFUSAL_KEYS, own(receipt, 'reason'), REFUSAL_KEYS.not_written);
+            else if (kind === 'unavailable')
+                key = pick(UNAVAILABLE_KEYS, own(receipt, 'cause'), UNAVAILABLE_KEYS.domain_not_hosted);
+            else if (kind === 'unknown')
+                key = pick(UNKNOWN_KEYS, own(receipt, 'cause'), UNKNOWN_KEYS.commit_unconfirmed);
+        }
+    }
+    catch {
+        key = REFUSAL_KEYS.not_written;
+    }
+    return renderMessage(msg(key), lang);
+}
+export function localConfigDisclosureSentence(disclosure, lang) {
+    try {
+        if (!isRecord(disclosure))
+            return undefined;
+        const kind = own(disclosure, 'kind');
+        if (typeof kind !== 'string' || !Object.hasOwn(DISCLOSURE_KEYS, kind))
+            return undefined;
+        const layer = own(disclosure, 'layer');
+        const layerKey = typeof layer === 'string' && Object.hasOwn(LAYER_KEYS, layer) ? LAYER_KEYS[layer] : 'config.localConfig.layer.other';
+        const detail = own(disclosure, 'detail');
+        if (Object.hasOwn(DISCLOSURE_NAMED_KEYS, kind) && typeof detail === 'string' && detail !== '') {
+            return renderMessage(msg(DISCLOSURE_NAMED_KEYS[kind], { layer: msg(layerKey), names: capForDisplay(detail, DETAIL_MAX) }), lang);
+        }
+        return renderMessage(msg(DISCLOSURE_KEYS[kind], { layer: msg(layerKey) }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function localConfigResidueSentence(residue, lang) {
+    if (typeof residue !== 'string' || !Object.hasOwn(RESIDUE_KEYS, residue))
+        return undefined;
+    return renderMessage(msg(RESIDUE_KEYS[residue]), lang);
+}