@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/localConfig/modelPool.js

@@ -0,0 +1,1489 @@
+import { PROVIDER_PRESETS, inferFamily } from '../model/providerPresets.js';
+import { SETTINGS_MODEL_API_WORDS } from '../generated/settingsSchemaTables.js';
+import { SETTINGS_NARROW_AT_MENTION, SETTINGS_RESOLVE_ACTIVE_TIERS } from '../generated/settingsSchemaFns.js';
+import { isLoopbackWireUrl } from '../engineWireSdk.js';
+import { resolveCatalogDefaultModel } from '../model/catalogDefault.js';
+import { TIER_ORDER, isTier, resolveTierBinding } from '../model/tierVocabulary.js';
+import { computeDeleteBlockers, computeDeleteWarnings, resolveEntryVision } from '../model/modelSupplyRules.js';
+import { routeKeyOf } from '../coreValuePorts.js';
+import { applyProbeToEntry } from '../modelCapabilityProbe.js';
+import { KEY_SLOT_PREFIX, keyEnvNameForEntry, onboardWriteVerdict, poolEntryNameOf, onboardBaseUrlProblem, onboardEntryCredentialIssue, onboardKeyCarriedBy, onboardRedactKey, } from '../model/onboardJudgement.js';
+import { ownSnapshotRecord, ownSnapshotRecordFaithful, readOwnDataValue } from '../ownKey.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { applyLocalConfigIntent, previewLocalConfigIntent } from './kernel.js';
+import { settingsWritePlan } from './settingsWrite.js';
+import { MODEL_POOL_CHANNEL_SOURCES, MODEL_POOL_EDIT_KINDS, MODEL_POOL_MAX_BATCH } from './modelPoolWords.js';
+export { MODEL_POOL_EDIT_KINDS, MODEL_POOL_CHANNEL_SOURCES, MODEL_POOL_CREDENTIAL_KINDS, MODEL_POOL_COMPLETENESS, MODEL_POOL_MAX_BATCH, MODEL_POOL_PROBE_STATES, MODEL_POOL_DEFAULT_KEEP_REASONS } from './modelPoolWords.js';
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function cloneDoc(v) {
+    const snap = ownSnapshotRecordFaithful(v);
+    return snap === undefined ? undefined : JSON.parse(JSON.stringify(snap));
+}
+const freezeDoc = (v) => ownSnapshotRecord(v) ?? Object.freeze({});
+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);
+    return ka.length === kb.length && ka.every((k) => Object.hasOwn(b, k) && sameJson(a[k], b[k]));
+}
+const en = (key, params) => renderMessage(msg(key, params));
+const strOf = (v) => (typeof v === 'string' && v !== '' ? v : undefined);
+const posInt = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+const probeStateOf = (verdict) => (typeof verdict !== 'string' || verdict === '' ? 'unprobed' : verdict === 'ok' ? 'verified' : 'unverified');
+const ADD_REFUSAL_ORDER = Object.freeze(['changed_during_write', 'credential_unpaired', 'probe_failed', 'probe_unverified', 'invalid_request']);
+const batchRefusalOf = (problems) => ADD_REFUSAL_ORDER.find((r) => problems.some((p) => p.reason === r)) ?? 'invalid_request';
+const CATALOG_NAME_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+const refuse = (reason, problems = [], detail) => Object.freeze({ ok: false, reason, problems: Object.freeze([...problems]), ...(detail === undefined ? {} : { detail }) });
+const problem = (reason, detail, at) => Object.freeze({ reason, detail, ...(at?.index === undefined ? {} : { index: at.index }), ...(at?.name === undefined ? {} : { name: at.name }) });
+function modelsDocOf(raw) {
+    if (raw === null || raw === undefined) {
+        const models = [];
+        return { ok: true, doc: { models }, models };
+    }
+    const doc = cloneDoc(raw);
+    if (doc === undefined)
+        return { ok: false, detail: en('onboard.plan.notObject') };
+    const list = doc['models'];
+    if (list !== undefined && !Array.isArray(list))
+        return { ok: false, detail: en('onboard.plan.modelsNotList') };
+    const models = Array.isArray(list) ? list : [];
+    if (models.some((m) => !isRecord(m)))
+        return { ok: false, detail: en('onboard.plan.modelsItemNotObject') };
+    doc['models'] = models;
+    return { ok: true, doc, models: models };
+}
+function defaultSlotOf(doc) {
+    const roles = doc['roles'];
+    if (roles !== undefined && !isRecord(roles))
+        return { kind: 'unreadable' };
+    const target = isRecord(roles) ? roles['default'] : undefined;
+    if (target !== undefined) {
+        if (!isRecord(target))
+            return { kind: 'unreadable' };
+        const model = target['model'];
+        const select = target['select'];
+        if (model !== undefined && typeof model !== 'string')
+            return { kind: 'unreadable' };
+        if ((model === undefined || model === '') && select !== undefined && !isRecord(select))
+            return { kind: 'unreadable' };
+        return { kind: 'set', target, legacy: false };
+    }
+    const legacy = doc['default'];
+    if (legacy === undefined)
+        return { kind: 'absent' };
+    return typeof legacy === 'string' && legacy !== '' ? { kind: 'set', target: { model: legacy }, legacy: true } : { kind: 'unreadable' };
+}
+function withDefaultFolded(doc) {
+    if (!Object.hasOwn(doc, 'default'))
+        return doc;
+    const slot = defaultSlotOf(doc);
+    if (slot.kind !== 'set')
+        return doc;
+    const out = { ...doc };
+    delete out['default'];
+    if (slot.legacy)
+        out['roles'] = { ...(isRecord(doc['roles']) ? doc['roles'] : {}), default: slot.target };
+    return out;
+}
+function catalogRowsOf(items) {
+    const rows = [];
+    const seen = new Set();
+    let unreadable = 0;
+    for (const m of items) {
+        const n = isRecord(m) ? strOf(m['name']) : undefined;
+        if (n === undefined || !CATALOG_NAME_RE.test(n) || seen.has(n) || typeof m['id'] !== 'string') {
+            unreadable += 1;
+            continue;
+        }
+        seen.add(n);
+        rows.push(m);
+    }
+    return { rows, unreadable };
+}
+function settingsDocOf(raw) {
+    if (raw === null || raw === undefined)
+        return { ok: true, doc: {}, env: {} };
+    const doc = cloneDoc(raw);
+    if (doc === undefined)
+        return { ok: false, detail: en('onboard.plan.envNotObject') };
+    const env = doc['env'];
+    if (env !== undefined && !isRecord(env))
+        return { ok: false, detail: en('onboard.plan.envNotObject') };
+    return { ok: true, doc, env: isRecord(env) ? env : {} };
+}
+const entryName = (m) => strOf(m['name']);
+const isEnabled = (m) => m['enabled'] !== false;
+const isShellSlotIn = (env) => (ref) => typeof ref === 'string' && ref.startsWith(KEY_SLOT_PREFIX) && typeof env[ref] === 'string';
+function referencedSlotsOf(models) {
+    const out = new Set();
+    for (const m of models)
+        if (typeof m['apiKeyEnv'] === 'string')
+            out.add(m['apiKeyEnv'].toUpperCase());
+    return out;
+}
+function orphanKeySlotsOf(models, env) {
+    const referenced = referencedSlotsOf(models);
+    const isSlot = isShellSlotIn(env);
+    return Object.keys(env).filter((k) => isSlot(k) && !referenced.has(k.toUpperCase()));
+}
+function envModelOf(env) {
+    return [env['MODEL_ID'], env['MODEL_CHEAP_ID']].find((v) => typeof v === 'string' && v.trim() !== '');
+}
+const envServesModels = (models, env) => models.some(isEnabled) ? undefined : envModelOf(env);
+function tierGroupsOf(doc) {
+    const g = doc['tierGroups'];
+    return Array.isArray(g) ? g.filter(isRecord) : [];
+}
+function legacyTierGroupsOf(settings) {
+    const raw = settings['semaTierGroups'];
+    if (!isRecord(raw) || typeof raw['active'] !== 'string' || !isRecord(raw['groups']))
+        return null;
+    const groups = {};
+    const defaultTiers = {};
+    for (const [name, def] of Object.entries(raw['groups'])) {
+        if (!isRecord(def) || !isRecord(def['tiers']))
+            continue;
+        const tiers = {};
+        for (const [k, v] of Object.entries(def['tiers']))
+            if (isTier(k) && typeof v === 'string' && v !== '')
+                tiers[k] = v;
+        groups[name] = { tiers };
+        defaultTiers[name] = isTier(def['defaultTier']) ? def['defaultTier'] : undefined;
+    }
+    if (Object.keys(groups).length === 0)
+        return null;
+    const active = Object.hasOwn(groups, raw['active']) ? raw['active'] : Object.keys(groups)[0];
+    return { active, groups, defaultTiers };
+}
+function legacyRostersOf(settings) {
+    const raw = settings['semaRosters'];
+    if (!isRecord(raw) || typeof raw['active'] !== 'string' || !isRecord(raw['rosters']))
+        return null;
+    const rosters = {};
+    for (const [name, def] of Object.entries(raw['rosters'])) {
+        if (!isRecord(def) || !isRecord(def['slots']))
+            continue;
+        const slots = {};
+        for (const [k, v] of Object.entries(def['slots']))
+            if (typeof v === 'string')
+                slots[k] = v;
+        rosters[name] = { slots };
+    }
+    return { active: raw['active'], rosters };
+}
+function settingsOrEmpty(raw) {
+    const r = settingsDocOf(raw);
+    return r.ok ? r.doc : (cloneDoc(raw) ?? {});
+}
+function settingsAfter(doc, edits) {
+    if (edits.length === 0)
+        return { ok: true, next: doc };
+    const r = settingsWritePlan({ doc: 'userSettings', current: doc, trust: 'no_trust_step', edits });
+    if (!r.ok)
+        return { ok: false, reason: r.reason, ...(r.detail === undefined ? {} : { detail: r.detail }) };
+    return { ok: true, next: cloneDoc(r.next) ?? {} };
+}
+function shadowDisclosuresOf(settings) {
+    const model = own(settings, 'model');
+    return typeof model === 'string' && model.trim() !== '' ? Object.freeze([Object.freeze({ kind: 'shadowed_by', layer: 'userSettings', detail: 'model' })]) : Object.freeze([]);
+}
+const noneDefault = (disclosures) => Object.freeze({ kind: 'none', disclosures });
+const unknownDefault = (disclosures) => Object.freeze({ kind: 'unknown', disclosures });
+export function effectiveDefaultModelOf(input) {
+    const disclosures = shadowDisclosuresOf(own(input, 'userSettings'));
+    try {
+        const raw = own(input, 'modelsDoc');
+        if (raw === null || raw === undefined)
+            return noneDefault(disclosures);
+        const doc = cloneDoc(raw);
+        if (doc === undefined)
+            return unknownDefault(disclosures);
+        const list = doc['models'];
+        if (list !== undefined && !Array.isArray(list))
+            return unknownDefault(disclosures);
+        const folded = withDefaultFolded(doc);
+        if (defaultSlotOf(folded).kind === 'unreadable')
+            return unknownDefault(disclosures);
+        const enabled = catalogRowsOf(Array.isArray(list) ? list : []).rows.filter(isEnabled).map((m) => strOf(m['name']));
+        if (enabled.length === 0)
+            return noneDefault(disclosures);
+        const set = new Set(enabled);
+        const r = resolveCatalogDefaultModel(folded, (n) => set.has(n), enabled[0]);
+        if (r.kind === 'select')
+            return Object.freeze({ kind: 'select', select: r.select, disclosures });
+        return Object.freeze({ kind: 'named', name: r.name, source: r.source, dangling: r.dangling, disclosures });
+    }
+    catch {
+        return unknownDefault(disclosures);
+    }
+}
+const keepDefault = (reason) => Object.freeze({ kind: 'unchanged', reason });
+export function defaultModelChoiceOf(existing, batch, declined) {
+    try {
+        if (declined === true)
+            return keepDefault('declined');
+        if (!Array.isArray(batch) || batch.length === 0)
+            return keepDefault('nothing_added');
+        const kind = own(existing, 'kind');
+        if (kind === 'named') {
+            const source = own(existing, 'source');
+            if (typeof source !== 'string')
+                return keepDefault('existing_unknown');
+            if (source !== 'fallback')
+                return keepDefault('has_default');
+        }
+        else if (kind === 'select')
+            return keepDefault('has_default');
+        else if (kind === 'unknown')
+            return keepDefault('existing_unknown');
+        else if (kind !== 'none')
+            return keepDefault('existing_unknown');
+        for (let i = 0; i < batch.length; i++)
+            if (own(own(batch, String(i)), 'probe') === 'verified')
+                return Object.freeze({ kind: 'pick', index: i });
+        return keepDefault('none_verified');
+    }
+    catch {
+        return keepDefault('existing_unknown');
+    }
+}
+function specOf(v, index) {
+    const bad = (detail) => ({ ok: false, problem: problem('invalid_request', detail, { index }) });
+    if (!isRecord(v))
+        return bad(en('onboard.refusal.input'));
+    const modelId = own(v, 'modelId');
+    const api = own(v, 'api');
+    const baseUrl = own(v, 'baseUrl');
+    const cred = own(v, 'credential');
+    if (typeof modelId !== 'string' || modelId.trim() === '' || modelId.length > 512)
+        return bad(en('onboard.refusal.input'));
+    if (!SETTINGS_MODEL_API_WORDS.some((w) => w === api))
+        return bad(en('onboard.refusal.input'));
+    if (typeof baseUrl !== 'string')
+        return bad(en('onboard.baseUrl.invalid'));
+    const urlProblem = onboardBaseUrlProblem(baseUrl);
+    if (urlProblem !== undefined)
+        return bad(urlProblem);
+    const credKind = own(cred, 'kind');
+    const apiKey = own(cred, 'apiKey');
+    let credential;
+    if (credKind === 'none')
+        credential = { kind: 'none' };
+    else if (credKind === 'key' && typeof apiKey === 'string' && apiKey.trim() !== '')
+        credential = { kind: 'key', apiKey };
+    else
+        return bad(en('onboard.refusal.input'));
+    const label = own(v, 'label');
+    const vision = own(v, 'vision');
+    const ctx = own(v, 'contextWindow');
+    const max = own(v, 'maxTokens');
+    const channel = own(v, 'channel');
+    const probeRaw = own(v, 'probe');
+    const accept = own(v, 'acceptUnverified');
+    if ((label !== undefined && (typeof label !== 'string' || label.length > 200)) || (vision !== undefined && typeof vision !== 'boolean'))
+        return bad(en('onboard.refusal.input'));
+    if (accept !== undefined && typeof accept !== 'boolean')
+        return bad(en('onboard.refusal.input'));
+    if ((ctx !== undefined && !posInt(ctx)) || (max !== undefined && !posInt(max)))
+        return bad(en('onboard.refusal.input'));
+    if (channel !== undefined && (typeof channel !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(channel)))
+        return bad(en('onboard.refusal.input'));
+    let probe;
+    if (probeRaw !== undefined) {
+        const verdict = own(probeRaw, 'verdict');
+        const at = own(probeRaw, 'at');
+        if (typeof verdict !== 'string' || verdict === '' || typeof at !== 'number' || !Number.isFinite(at))
+            return bad(en('onboard.refusal.input'));
+        probe = { verdict: verdict, at };
+    }
+    const thinking = own(v, 'thinking');
+    return {
+        ok: true,
+        spec: {
+            modelId,
+            api: api,
+            baseUrl,
+            credential,
+            ...(typeof label === 'string' && label !== '' ? { label } : {}),
+            ...(typeof vision === 'boolean' ? { vision } : {}),
+            ...(posInt(ctx) ? { contextWindow: ctx } : {}),
+            ...(posInt(max) ? { maxTokens: max } : {}),
+            ...(typeof channel === 'string' ? { channel } : {}),
+            ...(probe === undefined ? {} : { probe }),
+            ...(accept === true ? { acceptUnverified: true } : {}),
+            ...(thinking === undefined ? {} : { thinking }),
+        },
+    };
+}
+function otherIssuesOf(models, skip, env, say) {
+    const out = [];
+    for (const m of models) {
+        const name = entryName(m);
+        if (!isEnabled(m) || (name !== undefined && skip.has(name)))
+            continue;
+        const issue = onboardEntryCredentialIssue(m, env);
+        if (issue !== undefined)
+            out.push(Object.freeze({ name: name ?? '?', modelId: strOf(m['id']) ?? '?', issue: say(issue) }));
+    }
+    return out;
+}
+function planAdd(rawEntries, defaultIndex, modelsRaw, settingsRaw, env, pins, declineDefault) {
+    if (!Array.isArray(rawEntries) || rawEntries.length === 0 || rawEntries.length > MODEL_POOL_MAX_BATCH)
+        return refuse('invalid_request', [problem('invalid_request', en('onboard.refusal.input'))]);
+    const specs = [];
+    const problems = [];
+    for (let i = 0; i < rawEntries.length; i++) {
+        const r = specOf(own(rawEntries, String(i)), i);
+        if (r.ok)
+            specs.push(r.spec);
+        else
+            problems.push(r.problem);
+    }
+    const keys = specs.flatMap((s) => (s.credential.kind === 'key' ? [s.credential.apiKey] : []));
+    const say = (t) => keys.reduce((acc, k) => onboardRedactKey(acc, k), t);
+    if (problems.length > 0)
+        return refuse('invalid_request', problems.map((p) => ({ ...p, detail: say(p.detail) })));
+    if (defaultIndex !== undefined && (!Number.isSafeInteger(defaultIndex) || defaultIndex < 0 || defaultIndex >= specs.length)) {
+        return refuse('invalid_request', [problem('invalid_request', en('onboard.refusal.input'))]);
+    }
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const { models } = mread;
+    const doc = withDefaultFolded(mread.doc);
+    const envModel = envServesModels(models, env);
+    if (envModel !== undefined)
+        return refuse('env_catalog_present', [], say(en('onboard.plan.envCatalogPresent', { model: envModel })));
+    const sread = settingsDocOf(settingsRaw);
+    if (!sread.ok)
+        return refuse('scope_unreadable', [], sread.detail);
+    const prevEnv = sread.env;
+    const isShellSlot = isShellSlotIn(prevEnv);
+    const original = models.length;
+    const taken = new Set(models.map(entryName).filter((n) => n !== undefined));
+    const usedSlots = new Set();
+    for (const m of models)
+        if (typeof m['apiKeyEnv'] === 'string')
+            usedSlots.add(m['apiKeyEnv'].toUpperCase());
+    for (const k of Object.keys(prevEnv))
+        usedSlots.add(k.toUpperCase());
+    for (const [k, v] of Object.entries(env))
+        if (typeof v === 'string')
+            usedSlots.add(k.toUpperCase());
+    const referenced = referencedSlotsOf(models);
+    const orphan = (slot) => isShellSlot(slot) && !referenced.has(slot.toUpperCase());
+    const planned = [];
+    const replaced = [];
+    const slotEdits = [];
+    const envView = { ...env };
+    const targets = new Set();
+    for (let i = 0; i < specs.length; i++) {
+        const e = specs[i];
+        const pin = pins?.entries[i];
+        const verdict = onboardWriteVerdict(e.probe?.verdict, e.acceptUnverified === true);
+        if (!verdict.write) {
+            problems.push(problem(verdict.refusal, say(en(verdict.refusal === 'probe_failed' ? 'model.pool.add.probeFailed' : 'model.pool.add.probeUnverified', { model: e.modelId })), { index: i }));
+            continue;
+        }
+        const targetKey = routeKeyOf(e.baseUrl);
+        if (targetKey === undefined) {
+            problems.push(problem('credential_unpaired', say(en('onboard.catalog.judgeAbsent', { name: e.modelId })), { index: i }));
+            continue;
+        }
+        const sig = `${e.modelId}\u0000${e.api}\u0000${targetKey}`;
+        if (targets.has(sig)) {
+            problems.push(problem('invalid_request', say(en('model.pool.add.duplicate', { model: e.modelId })), { index: i }));
+            continue;
+        }
+        targets.add(sig);
+        const keyed = e.credential.kind === 'key';
+        const sameTarget = (m) => m['id'] === e.modelId && m['api'] === e.api && typeof m['baseUrl'] === 'string' && routeKeyOf(m['baseUrl']) === targetKey;
+        const existingIdx = models.findIndex((m, idx) => idx < original &&
+            sameTarget(m) &&
+            isEnabled(m) &&
+            m['sealedApiKey'] === undefined &&
+            (keyed ? m['apiKeyEnv'] === undefined || isShellSlot(m['apiKeyEnv']) : m['apiKeyEnv'] === undefined));
+        let name;
+        if (pin !== undefined) {
+            name = pin.name;
+            const holder = models.findIndex((m) => entryName(m) === name);
+            if (holder >= 0 && holder !== existingIdx) {
+                problems.push(problem('changed_during_write', say(en('model.pool.add.pinMoved', { name })), { index: i, name }));
+                continue;
+            }
+        }
+        else
+            name = existingIdx >= 0 ? String(models[existingIdx]['name']) : poolEntryNameOf(e.modelId, e.channel ?? 'custom', taken);
+        taken.add(name);
+        let keyEnv = null;
+        if (keyed) {
+            const apiKey = e.credential.apiKey;
+            if (pin !== undefined) {
+                if (pin.keyEnv === null || prevEnv[pin.keyEnv] !== apiKey) {
+                    problems.push(problem('changed_during_write', say(en('model.pool.add.pinMoved', { name })), { index: i, name }));
+                    continue;
+                }
+                keyEnv = pin.keyEnv;
+            }
+            else {
+                const existingRef = existingIdx >= 0 ? models[existingIdx]['apiKeyEnv'] : undefined;
+                const sharedByOther = typeof existingRef === 'string' &&
+                    models.some((m, idx) => idx !== existingIdx && typeof m['apiKeyEnv'] === 'string' && m['apiKeyEnv'].toUpperCase() === existingRef.toUpperCase());
+                if (isShellSlot(existingRef) && !sharedByOther && prevEnv[existingRef] === apiKey)
+                    keyEnv = existingRef;
+                else {
+                    const baseSlot = keyEnvNameForEntry(name);
+                    let slot = baseSlot;
+                    if (!(orphan(slot) && !slotEdits.some((s) => s.member === slot)))
+                        for (let n = 2; usedSlots.has(slot.toUpperCase()); n++)
+                            slot = `${baseSlot}_${n}`;
+                    keyEnv = slot;
+                }
+                usedSlots.add(keyEnv.toUpperCase());
+                if (prevEnv[keyEnv] !== apiKey)
+                    slotEdits.push({ intent: 'modelKeySlot', member: keyEnv, op: 'set', value: apiKey });
+            }
+            envView[keyEnv] = apiKey;
+            if (onboardKeyCarriedBy(name, apiKey) || onboardKeyCarriedBy(keyEnv, apiKey)) {
+                problems.push(problem('invalid_request', say(en('onboard.input.keyInFields')), { index: i }));
+                continue;
+            }
+        }
+        const base = existingIdx >= 0 ? models[existingIdx] : {};
+        let entry = {
+            ...base,
+            name,
+            id: e.modelId,
+            provider: e.api === 'anthropic-messages' ? 'anthropic' : 'gateway',
+            api: e.api,
+            baseUrl: e.baseUrl,
+            ...(typeof base['contextWindow'] === 'number' ? {} : e.contextWindow !== undefined ? { contextWindow: e.contextWindow } : {}),
+            ...(typeof base['maxTokens'] === 'number' ? {} : e.maxTokens !== undefined ? { maxTokens: e.maxTokens } : {}),
+            ...(keyEnv === null ? {} : { apiKeyEnv: keyEnv }),
+            semaChannel: typeof base['semaChannel'] === 'string' ? base['semaChannel'] : (e.channel ?? 'custom'),
+            ...(typeof base['semaLabel'] === 'string' ? {} : e.label !== undefined ? { semaLabel: e.label } : {}),
+            ...(e.probe === undefined ? {} : { semaProbe: e.probe.verdict, semaProbeAt: e.probe.at }),
+        };
+        if (keyEnv === null)
+            delete entry['apiKeyEnv'];
+        if (e.probe === undefined) {
+            delete entry['semaProbe'];
+            delete entry['semaProbeAt'];
+        }
+        if (e.vision !== undefined) {
+            entry['vision'] = e.vision;
+            entry['semaVision'] = e.vision;
+        }
+        else if (entry['vision'] === undefined) {
+            const fam = resolveEntryVision({ modelId: e.modelId }).value;
+            if (fam !== undefined)
+                entry['vision'] = fam;
+        }
+        if (e.thinking !== undefined) {
+            const probed = applyProbeToEntry({ ...(typeof entry['reasoning'] === 'boolean' ? { reasoning: entry['reasoning'] } : {}), ...(entry['compat'] !== undefined ? { compat: entry['compat'] } : {}) }, e.thinking);
+            const next = { ...entry };
+            if (typeof probed.reasoning === 'boolean')
+                next['reasoning'] = probed.reasoning;
+            if (probed.compat !== undefined)
+                next['compat'] = probed.compat;
+            else
+                delete next['compat'];
+            entry = next;
+        }
+        const issue = onboardEntryCredentialIssue(entry, envView);
+        if (issue !== undefined) {
+            problems.push(problem('credential_unpaired', say(issue), { index: i, name }));
+            continue;
+        }
+        const prevRef = existingIdx >= 0 ? models[existingIdx]['apiKeyEnv'] : undefined;
+        if (isShellSlot(prevRef) && prevRef.toUpperCase() !== (keyEnv ?? '').toUpperCase())
+            replaced.push(prevRef);
+        if (existingIdx >= 0)
+            models[existingIdx] = entry;
+        else
+            models.push(entry);
+        planned.push(Object.freeze({ name, modelId: e.modelId, keyEnv, updatedExisting: existingIdx >= 0, probe: probeStateOf(entry['semaProbe']) }));
+    }
+    if (problems.length > 0)
+        return refuse(batchRefusalOf(problems), problems);
+    let defaultAt = defaultIndex;
+    if (defaultAt === undefined) {
+        const choice = defaultModelChoiceOf(effectiveDefaultModelOf({ modelsDoc: modelsRaw, userSettings: settingsRaw }), planned, declineDefault);
+        if (choice.kind === 'pick')
+            defaultAt = choice.index;
+    }
+    if (defaultAt !== undefined) {
+        const roles = isRecord(doc['roles']) ? doc['roles'] : {};
+        roles['default'] = { model: planned[defaultAt].name };
+        doc['roles'] = roles;
+    }
+    const settings = settingsAfter(sread.doc, slotEdits);
+    if (!settings.ok)
+        return refuse(settings.reason, [], settings.detail);
+    const skip = new Set(planned.map((p) => p.name));
+    const stillReferenced = referencedSlotsOf(models);
+    const releasedKeySlots = replaced.filter((r, i) => replaced.indexOf(r) === i && !stillReferenced.has(r.toUpperCase()));
+    return okPlan(modelsRaw, doc, settingsRaw, settings.next, { entries: planned, releasedKeySlots, otherIssues: otherIssuesOf(models, skip, envView, say) });
+}
+function okPlan(modelsRaw, nextModels, settingsRaw, nextSettings, extra) {
+    const before = modelsRaw === null || modelsRaw === undefined ? undefined : cloneDoc(modelsRaw);
+    const sBefore = settingsRaw === null || settingsRaw === undefined ? {} : (cloneDoc(settingsRaw) ?? {});
+    return Object.freeze({
+        ok: true,
+        nextModelsDoc: freezeDoc(nextModels),
+        nextSettingsDoc: freezeDoc(nextSettings),
+        modelsChanged: before === undefined ? !sameJson(nextModels, { models: [] }) : !sameJson(before, nextModels),
+        settingsChanged: !sameJson(sBefore, nextSettings),
+        entries: Object.freeze([...(extra.entries ?? [])]),
+        releasedKeySlots: Object.freeze([...(extra.releasedKeySlots ?? [])]),
+        warnings: Object.freeze([...(extra.warnings ?? [])]),
+        otherIssues: Object.freeze([...(extra.otherIssues ?? [])]),
+        disclosures: Object.freeze([...(extra.disclosures ?? [])]),
+    });
+}
+function bindingsOf(group) {
+    const out = {};
+    if (isRecord(group['tiers']))
+        for (const [k, v] of Object.entries(group['tiers']))
+            if (isTier(k) && typeof v === 'string' && v !== '')
+                out[k] = v;
+    return out;
+}
+function detachEntry(doc, name, surviving) {
+    const groups = tierGroupsOf(doc);
+    if (groups.length > 0) {
+        const kept = [];
+        for (const g of groups) {
+            const had = Object.keys(bindingsOf(g)).length;
+            const tiers = isRecord(g['tiers']) ? { ...g['tiers'] } : {};
+            for (const [k, v] of Object.entries(tiers))
+                if (v === name)
+                    delete tiers[k];
+            const left = Object.keys(tiers).filter((k) => isTier(k) && typeof tiers[k] === 'string').length;
+            if (had > 0 && left === 0)
+                continue;
+            kept.push({ ...g, tiers });
+        }
+        doc['tierGroups'] = kept;
+        if (typeof doc['activeTierGroup'] === 'string' && !kept.some((g) => g['name'] === doc['activeTierGroup']))
+            delete doc['activeTierGroup'];
+    }
+    const am = doc['atMention'];
+    if (isRecord(am) && am['mode'] === 'only' && Array.isArray(am['models'])) {
+        const narrowed = SETTINGS_NARROW_AT_MENTION(am, surviving);
+        doc['atMention'] = narrowed;
+    }
+}
+function planRemove(name, modelsRaw, settingsRaw) {
+    if (typeof name !== 'string' || name === '')
+        return refuse('invalid_request');
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const sread = settingsDocOf(settingsRaw);
+    if (!sread.ok)
+        return refuse('scope_unreadable', [], sread.detail);
+    const { doc, models } = mread;
+    const idx = models.findIndex((m) => entryName(m) === name);
+    if (idx < 0)
+        return refuse('not_found', [problem('not_found', en('model.pool.notFound', { name }), { name })]);
+    const blockers = computeDeleteBlockers({ id: name, doc: withDefaultFolded(doc), rosters: legacyRostersOf(sread.doc) });
+    if (blockers.length > 0)
+        return refuse('entry_in_use', blockers.map((b) => problem('entry_in_use', `${b.where}: ${b.fix}`, { name })));
+    const surviving = models.filter((_, i) => i !== idx).map(entryName).filter((n) => n !== undefined);
+    const warnings = computeDeleteWarnings({ id: name, doc: doc, tierGroups: legacyTierGroupsOf(sread.doc), survivingIds: surviving });
+    const removed = models[idx];
+    models.splice(idx, 1);
+    detachEntry(doc, name, new Set(surviving));
+    const ref = removed['apiKeyEnv'];
+    const released = isShellSlotIn(sread.env)(ref) && !models.some((m) => typeof m['apiKeyEnv'] === 'string' && m['apiKeyEnv'].toUpperCase() === ref.toUpperCase()) ? [ref] : [];
+    return okPlan(modelsRaw, doc, settingsRaw, sread.doc, { releasedKeySlots: released, warnings });
+}
+function planUpdate(edit, modelsRaw, settingsRaw) {
+    const name = own(edit, 'name');
+    if (typeof name !== 'string' || name === '')
+        return refuse('invalid_request');
+    const label = own(edit, 'label');
+    const vision = own(edit, 'vision');
+    const ctx = own(edit, 'contextWindow');
+    const max = own(edit, 'maxTokens');
+    if (label === undefined && vision === undefined && ctx === undefined && max === undefined)
+        return refuse('invalid_request');
+    if ((label !== undefined && label !== null && (typeof label !== 'string' || label.length > 200)) || (vision !== undefined && vision !== null && typeof vision !== 'boolean'))
+        return refuse('invalid_request');
+    if ((ctx !== undefined && !posInt(ctx)) || (max !== undefined && !posInt(max)))
+        return refuse('invalid_request');
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const { doc, models } = mread;
+    const m = models.find((x) => entryName(x) === name);
+    if (m === undefined)
+        return refuse('not_found', [problem('not_found', en('model.pool.notFound', { name }), { name })]);
+    if (label === null || label === '')
+        delete m['semaLabel'];
+    else if (typeof label === 'string')
+        m['semaLabel'] = label;
+    if (vision === null) {
+        delete m['semaVision'];
+        const fam = typeof m['id'] === 'string' ? resolveEntryVision({ modelId: m['id'] }).value : undefined;
+        if (fam === undefined)
+            delete m['vision'];
+        else
+            m['vision'] = fam;
+    }
+    else if (typeof vision === 'boolean') {
+        m['vision'] = vision;
+        m['semaVision'] = vision;
+    }
+    if (posInt(ctx))
+        m['contextWindow'] = ctx;
+    if (posInt(max))
+        m['maxTokens'] = max;
+    return okPlan(modelsRaw, doc, settingsRaw, settingsOrEmpty(settingsRaw), {});
+}
+function planSetDefault(name, modelsRaw, settingsRaw) {
+    if (typeof name !== 'string' || name === '')
+        return refuse('invalid_request');
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const { models } = mread;
+    const doc = withDefaultFolded(mread.doc);
+    const m = models.find((x) => entryName(x) === name);
+    if (m === undefined || !isEnabled(m))
+        return refuse('not_found', [problem('not_found', en('model.pool.notFound', { name }), { name })]);
+    const roles = isRecord(doc['roles']) ? doc['roles'] : {};
+    roles['default'] = { model: name };
+    doc['roles'] = roles;
+    return okPlan(modelsRaw, doc, settingsRaw, settingsOrEmpty(settingsRaw), { disclosures: shadowDisclosuresOf(settingsRaw) });
+}
+function planImportEnv(modelsRaw, settingsRaw, env) {
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const envModel = envServesModels(mread.models, env);
+    if (envModel !== undefined)
+        return refuse('env_catalog_present', [], en('model.pool.importEnv.notYet', { model: envModel }));
+    return okPlan(modelsRaw, mread.doc, settingsRaw, settingsOrEmpty(settingsRaw), {});
+}
+function planTier(kind, edit, modelsRaw, settingsRaw) {
+    const group = own(edit, 'group');
+    if (typeof group !== 'string' || !CATALOG_NAME_RE.test(group) || group.length > 64)
+        return refuse('invalid_request', [problem('invalid_request', en('model.pool.tier.badGroup'))]);
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const { doc, models } = mread;
+    const names = new Set(models.map(entryName).filter((n) => n !== undefined));
+    const groups = tierGroupsOf(doc);
+    const at = groups.findIndex((g) => g['name'] === group);
+    const missing = () => refuse('not_found', [problem('not_found', en('model.pool.tier.noGroup', { group }), { name: group })]);
+    if (kind === 'addTierGroup') {
+        if (at >= 0)
+            return refuse('already_exists', [problem('already_exists', en('model.pool.tier.groupExists', { group }), { name: group })]);
+        const tiersRaw = own(edit, 'tiers');
+        const tiers = {};
+        if (tiersRaw !== undefined) {
+            if (!isRecord(tiersRaw))
+                return refuse('invalid_request');
+            for (const [k, v] of Object.entries(tiersRaw)) {
+                if (!isTier(k) || typeof v !== 'string')
+                    return refuse('invalid_request');
+                if (!names.has(v))
+                    return refuse('not_found', [problem('not_found', en('model.pool.notFound', { name: v }), { name: v })]);
+                tiers[k] = v;
+            }
+        }
+        doc['tierGroups'] = [...(Array.isArray(doc['tierGroups']) ? doc['tierGroups'] : []), { name: group, tiers }];
+    }
+    else {
+        if (at < 0)
+            return missing();
+        if (kind === 'switchTierGroup')
+            doc['activeTierGroup'] = group;
+        else if (kind === 'removeTierGroup') {
+            doc['tierGroups'] = doc['tierGroups'].filter((g) => !(isRecord(g) && g['name'] === group));
+            if (doc['activeTierGroup'] === group)
+                delete doc['activeTierGroup'];
+        }
+        else {
+            const tier = own(edit, 'tier');
+            const target = own(edit, 'name');
+            if (!isTier(tier) || (target !== null && typeof target !== 'string'))
+                return refuse('invalid_request');
+            if (typeof target === 'string' && !names.has(target))
+                return refuse('not_found', [problem('not_found', en('model.pool.notFound', { name: target }), { name: target })]);
+            const g = groups[at];
+            const tiers = isRecord(g['tiers']) ? { ...g['tiers'] } : {};
+            if (target === null)
+                delete tiers[tier];
+            else
+                tiers[tier] = target;
+            g['tiers'] = tiers;
+        }
+    }
+    return okPlan(modelsRaw, doc, settingsRaw, settingsOrEmpty(settingsRaw), {});
+}
+function migratedTierGroups(legacy, names) {
+    const taken = new Set();
+    const groups = [];
+    let active;
+    let activeDefault;
+    for (const [display, def] of Object.entries(legacy.groups)) {
+        const tiers = {};
+        for (const [t, id] of Object.entries(def.tiers))
+            if (isTier(t) && typeof id === 'string' && names.has(id))
+                tiers[t] = id;
+        if (Object.keys(tiers).length === 0)
+            continue;
+        let slug = display.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+/, '') || 'group';
+        const stem = slug;
+        for (let i = 2; taken.has(slug); i++)
+            slug = `${stem}-${i}`;
+        taken.add(slug);
+        groups.push({ name: slug, tiers });
+        if (display === legacy.active) {
+            active = slug;
+            const bound = resolveTierBinding({ tiers }, legacy.defaultTiers[display] ?? 'pro');
+            if (bound !== undefined && names.has(bound))
+                activeDefault = bound;
+        }
+    }
+    return { groups, active, activeDefault };
+}
+function rostersAsTierGroups(settings) {
+    const r = legacyRostersOf(settings);
+    if (r === null)
+        return null;
+    const groups = {};
+    for (const [name, def] of Object.entries(r.rosters)) {
+        const tiers = {};
+        if (def.slots['main'])
+            tiers['pro'] = def.slots['main'];
+        if (def.slots['cheap'] && def.slots['cheap'] !== def.slots['main'])
+            tiers['flash'] = def.slots['cheap'];
+        if (Object.keys(tiers).length > 0)
+            groups[name] = { tiers };
+    }
+    if (Object.keys(groups).length === 0)
+        return null;
+    return { active: Object.hasOwn(groups, r.active) ? r.active : Object.keys(groups)[0], groups, defaultTiers: {} };
+}
+function planMigrate(modelsRaw, settingsRaw) {
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const sread = settingsDocOf(settingsRaw);
+    if (!sread.ok)
+        return refuse('scope_unreadable', [], sread.detail);
+    const { models } = mread;
+    const doc = withDefaultFolded(mread.doc);
+    const settings = sread.doc;
+    const legacy = legacyTierGroupsOf(settings) ?? rostersAsTierGroups(settings);
+    const disclosures = [];
+    if (legacy !== null) {
+        const names = new Set(models.map(entryName).filter((n) => n !== undefined));
+        const m = migratedTierGroups(legacy, names);
+        const catalogGroups = tierGroupsOf(doc);
+        const present = new Map();
+        for (const g of catalogGroups)
+            if (typeof g['name'] === 'string' && !present.has(g['name']))
+                present.set(g['name'], g);
+        const rawList = doc['tierGroups'];
+        const merged = Array.isArray(rawList) ? [...rawList] : [];
+        const overridden = [];
+        for (const g of m.groups) {
+            const name = g['name'];
+            const there = present.get(name);
+            if (there === undefined)
+                merged.push(g);
+            else if (!sameJson(bindingsOf(there), g['tiers']))
+                overridden.push(name);
+        }
+        if (merged.length > (Array.isArray(rawList) ? rawList.length : 0))
+            doc['tierGroups'] = merged;
+        if (overridden.length > 0)
+            disclosures.push(Object.freeze({ kind: 'tier_group_overridden', layer: 'models', detail: overridden.join(', ') }));
+        if (catalogGroups.length === 0) {
+            if (m.groups.length > 0 && m.active !== undefined)
+                doc['activeTierGroup'] = m.active;
+            if (m.activeDefault !== undefined && defaultSlotOf(doc).kind === 'absent')
+                doc['roles'] = { ...(isRecord(doc['roles']) ? doc['roles'] : {}), default: { model: m.activeDefault } };
+        }
+    }
+    const edits = [];
+    if (settings['semaTierGroups'] !== undefined)
+        edits.push({ intent: 'legacyTierGroups', op: 'delete' });
+    if (settings['semaRosters'] !== undefined)
+        edits.push({ intent: 'legacyRosters', op: 'delete' });
+    const after = settingsAfter(settings, edits);
+    if (!after.ok)
+        return refuse(after.reason, [], after.detail);
+    return okPlan(modelsRaw, doc, settingsRaw, after.next, { disclosures });
+}
+function planSweep(modelsRaw, settingsRaw) {
+    const mread = modelsDocOf(modelsRaw);
+    if (!mread.ok)
+        return refuse('scope_unreadable', [], mread.detail);
+    const sread = settingsDocOf(settingsRaw);
+    if (!sread.ok)
+        return refuse('scope_unreadable', [], sread.detail);
+    const untouched = modelsRaw === null || modelsRaw === undefined ? { models: [] } : (cloneDoc(modelsRaw) ?? { models: [] });
+    const orphans = orphanKeySlotsOf(mread.models, sread.env);
+    if (orphans.length === 0)
+        return okPlan(modelsRaw, untouched, settingsRaw, sread.doc, {});
+    const after = settingsAfter(sread.doc, orphans.map((member) => ({ intent: 'modelKeySlot', member, op: 'delete' })));
+    if (!after.ok)
+        return refuse(after.reason, [], after.detail);
+    return okPlan(modelsRaw, untouched, settingsRaw, after.next, { releasedKeySlots: orphans });
+}
+export function poolWritePlan(edit, modelsDoc, settingsDoc, effectiveEnv) {
+    return planWith(edit, modelsDoc, settingsDoc, effectiveEnv, undefined);
+}
+function envOf(v) {
+    const out = {};
+    if (!isRecord(v))
+        return out;
+    for (const k of Object.keys(v)) {
+        const val = own(v, k);
+        if (typeof val === 'string')
+            out[k] = val;
+    }
+    return out;
+}
+function planWith(edit, modelsDoc, settingsDoc, effectiveEnv, pins, declineDefault = false) {
+    try {
+        const kind = own(edit, 'kind');
+        const env = envOf(effectiveEnv);
+        switch (MODEL_POOL_EDIT_KINDS.find((w) => w === kind)) {
+            case 'add':
+                return planAdd(own(edit, 'entries'), own(edit, 'defaultIndex'), modelsDoc, settingsDoc, env, pins, declineDefault);
+            case 'importChannel': {
+                const entries = channelImportEntries(own(edit, 'profile'), own(edit, 'modelIds'), own(edit, 'acceptUnverified'));
+                if (entries === undefined)
+                    return refuse('invalid_request', [problem('invalid_request', en('model.pool.channel.badPick'))]);
+                return planAdd(entries, own(edit, 'defaultIndex'), modelsDoc, settingsDoc, env, pins, declineDefault);
+            }
+            case 'update':
+                return planUpdate(edit, modelsDoc, settingsDoc);
+            case 'remove':
+                return planRemove(own(edit, 'name'), modelsDoc, settingsDoc);
+            case 'setDefault':
+                return planSetDefault(own(edit, 'name'), modelsDoc, settingsDoc);
+            case 'importEnvModels':
+                return planImportEnv(modelsDoc, settingsDoc, env);
+            case 'bindTier':
+            case 'switchTierGroup':
+            case 'addTierGroup':
+            case 'removeTierGroup':
+                return planTier(kind, edit, modelsDoc, settingsDoc);
+            case 'migrateTierGroups':
+                return planMigrate(modelsDoc, settingsDoc);
+            case 'sweepOrphanKeySlots':
+                return planSweep(modelsDoc, settingsDoc);
+            default:
+                return refuse('invalid_request');
+        }
+    }
+    catch {
+        return refuse('invalid_request');
+    }
+}
+function pinsOf(v) {
+    const list = own(v, 'entries');
+    if (!Array.isArray(list))
+        return undefined;
+    const entries = [];
+    for (let i = 0; i < list.length; i++) {
+        const e = own(list, String(i));
+        const name = own(e, 'name');
+        const keyEnv = own(e, 'keyEnv');
+        if (typeof name !== 'string' || (keyEnv !== null && typeof keyEnv !== 'string'))
+            return undefined;
+        entries.push(Object.freeze({ name, keyEnv }));
+    }
+    return Object.freeze({ entries: Object.freeze(entries) });
+}
+const docFrom = (r) => r === undefined ? 'unreadable' : r.status === 'loaded' ? r.doc : r.status === 'absent' ? null : 'unreadable';
+export function modelPoolIntentOf(edit, effectiveEnv, probe) {
+    const kind = own(edit, 'kind');
+    const record = (p) => {
+        if (probe !== undefined)
+            probe.plan = p;
+        return p;
+    };
+    const refuseStep = (p) => ({ kind: 'refuse', reason: p.reason, ...(p.detail !== undefined ? { detail: p.detail } : p.problems[0] !== undefined ? { detail: p.problems[0].detail } : {}) });
+    const needsSettings = kind === 'add' || kind === 'importChannel' || kind === 'remove' || kind === 'migrateTierGroups' || kind === 'sweepOrphanKeySlots';
+    const read = (input) => {
+        const models = docFrom(input.fresh.models);
+        const settings = docFrom(input.fresh.userSettings);
+        if (models === 'unreadable' || (settings === 'unreadable' && needsSettings))
+            return undefined;
+        return { models, settings: settings === 'unreadable' ? null : settings };
+    };
+    const modelsStep = (role, withPins) => ({
+        doc: 'models',
+        role,
+        snapshot: ['userSettings'],
+        plan: (input) => {
+            const r = read(input);
+            if (r === undefined)
+                return { kind: 'refuse', reason: 'scope_unreadable' };
+            const previewUnseen = own(input, 'mode') === 'preview' && own(input.carried, 'prepWrites') === true;
+            const pinsRaw = withPins && !previewUnseen ? own(input.carried, 'pins') : undefined;
+            const pins = pinsRaw === undefined ? undefined : pinsOf(pinsRaw);
+            if (pinsRaw !== undefined && pins === undefined)
+                return { kind: 'refuse', reason: 'invalid_request' };
+            const p = record(planWith(edit, r.models, r.settings, effectiveEnv, pins));
+            if (!p.ok)
+                return refuseStep(p);
+            const carry = { released: [...p.releasedKeySlots] };
+            const disclose = p.disclosures.length > 0 ? { disclose: p.disclosures } : {};
+            return p.modelsChanged ? { kind: 'write', next: p.nextModelsDoc, carry, ...disclose } : { kind: 'unchanged', carry, ...disclose };
+        },
+    });
+    const slotCleanup = {
+        doc: 'userSettings',
+        role: 'cleanup',
+        residue: 'orphan_key_slot',
+        snapshot: ['models'],
+        plan: (input) => {
+            const r = read(input);
+            if (r === undefined)
+                return { kind: 'refuse', reason: 'scope_unreadable' };
+            const released = own(input.carried, 'released');
+            const slots = Array.isArray(released) ? released.filter((s) => typeof s === 'string') : [];
+            const models = modelsDocOf(r.models);
+            if (!models.ok)
+                return { kind: 'refuse', reason: 'scope_unreadable' };
+            const still = referencedSlotsOf(models.models);
+            const edits = slots.filter((s) => !still.has(s.toUpperCase())).map((s) => ({ intent: 'modelKeySlot', member: s, op: 'delete' }));
+            const sread = settingsDocOf(r.settings);
+            if (!sread.ok)
+                return { kind: 'refuse', reason: 'scope_unreadable' };
+            const after = settingsAfter(sread.doc, edits);
+            if (!after.ok)
+                return { kind: 'refuse', reason: after.reason };
+            return sameJson(sread.doc, after.next) ? { kind: 'unchanged' } : { kind: 'write', next: freezeDoc(after.next) };
+        },
+    };
+    if (kind === 'add' || kind === 'importChannel') {
+        const prepare = {
+            doc: 'userSettings',
+            role: 'prepare',
+            residue: 'orphan_key_slot',
+            lock: ['models'],
+            plan: (input) => {
+                const r = read(input);
+                if (r === undefined)
+                    return { kind: 'refuse', reason: 'scope_unreadable' };
+                const p = record(planWith(edit, r.models, r.settings, effectiveEnv, undefined));
+                if (!p.ok)
+                    return refuseStep(p);
+                const carry = { pins: { entries: p.entries.map((e) => ({ name: e.name, keyEnv: e.keyEnv })) }, prepWrites: p.settingsChanged };
+                return p.settingsChanged ? { kind: 'write', next: p.nextSettingsDoc, carry } : { kind: 'unchanged', carry };
+            },
+        };
+        return Object.freeze({ appliesOn: 'engine_reload', steps: Object.freeze([prepare, modelsStep('effect', true), slotCleanup]) });
+    }
+    if (kind === 'remove')
+        return Object.freeze({ appliesOn: 'engine_reload', steps: Object.freeze([modelsStep('effect', false), slotCleanup]) });
+    if (kind === 'migrateTierGroups') {
+        const cleanup = {
+            doc: 'userSettings',
+            role: 'cleanup',
+            residue: 'legacy_tier_groups_left',
+            snapshot: ['models'],
+            plan: (input) => {
+                const r = read(input);
+                if (r === undefined)
+                    return { kind: 'refuse', reason: 'scope_unreadable' };
+                const p = planWith(edit, r.models, r.settings, effectiveEnv, undefined);
+                if (!p.ok)
+                    return { kind: 'refuse', reason: p.reason };
+                if (own(input, 'mode') !== 'preview' && p.modelsChanged)
+                    return { kind: 'refuse', reason: 'changed_during_write' };
+                return p.settingsChanged ? { kind: 'write', next: p.nextSettingsDoc } : { kind: 'unchanged' };
+            },
+        };
+        return Object.freeze({ appliesOn: 'engine_reload', steps: Object.freeze([modelsStep('effect', false), cleanup]) });
+    }
+    if (kind === 'sweepOrphanKeySlots') {
+        const sweep = {
+            doc: 'userSettings',
+            role: 'effect',
+            lock: ['models'],
+            plan: (input) => {
+                const r = read(input);
+                if (r === undefined)
+                    return { kind: 'refuse', reason: 'scope_unreadable' };
+                const p = record(planWith(edit, r.models, r.settings, effectiveEnv, undefined));
+                if (!p.ok)
+                    return refuseStep(p);
+                return p.settingsChanged ? { kind: 'write', next: p.nextSettingsDoc } : { kind: 'unchanged' };
+            },
+        };
+        return Object.freeze({ appliesOn: 'next_engine_start', steps: Object.freeze([sweep]) });
+    }
+    return Object.freeze({ appliesOn: 'engine_reload', steps: Object.freeze([modelsStep('effect', false)]) });
+}
+export async function editModelPoolWith(edit, store, facts, effectiveEnv, opts) {
+    const probe = { plan: undefined };
+    const intent = modelPoolIntentOf(edit, effectiveEnv, probe);
+    const receipt = own(opts, 'dryRun') === true ? await previewLocalConfigIntent(intent, store, facts) : await applyLocalConfigIntent(intent, store, facts);
+    const p = probe.plan;
+    if (p === undefined)
+        return Object.freeze({ receipt });
+    if (!p.ok)
+        return Object.freeze({ receipt, ...(p.problems.length > 0 ? { problems: p.problems } : {}) });
+    return Object.freeze({
+        receipt,
+        ...(p.entries.length > 0 ? { entries: p.entries } : {}),
+        ...(p.warnings.length > 0 ? { warnings: p.warnings } : {}),
+        ...(p.otherIssues.length > 0 ? { otherIssues: p.otherIssues } : {}),
+    });
+}
+export function onboardWritePlan(input) {
+    const e = own(input, 'entry');
+    const apiKey = own(e, 'apiKey');
+    const say = (t) => (typeof apiKey === 'string' && apiKey !== '' ? onboardRedactKey(t, apiKey) : t);
+    const fail = (refusal, detail) => Object.freeze({ ok: false, refusal, detail: say(detail) });
+    try {
+        if (own(input, 'engineMode') === 'cloud')
+            return fail('engine_is_remote', en('onboard.refusal.engineIsRemote'));
+        const modelsRaw = own(input, 'modelsDoc');
+        if (modelsRaw !== undefined && !isRecord(modelsRaw))
+            return fail('catalog_unreadable', en('onboard.plan.notObject'));
+        const envRaw = own(input, 'settingsEnv');
+        const probe = own(input, 'probe');
+        const verdict = own(probe, 'verdict');
+        const now = own(input, 'now');
+        const spec = {
+            modelId: own(e, 'modelId'),
+            api: own(e, 'api'),
+            baseUrl: own(e, 'baseUrl'),
+            credential: { kind: 'key', apiKey },
+            label: own(e, 'providerName'),
+            contextWindow: own(e, 'contextWindow'),
+            maxTokens: own(e, 'maxTokens'),
+            channel: own(e, 'channel'),
+            probe: { verdict, at: now },
+            acceptUnverified: true,
+            ...(own(input, 'thinking') === undefined ? {} : { thinking: own(input, 'thinking') }),
+        };
+        const plan = planWith({ kind: 'add', entries: [spec], ...(own(input, 'makeDefault') === true ? { defaultIndex: 0 } : {}) }, modelsRaw === undefined ? null : modelsRaw, envRaw === undefined ? null : { env: envRaw }, own(input, 'effectiveEnv'), undefined, own(input, 'makeDefault') !== true);
+        if (!plan.ok) {
+            const first = plan.problems[0];
+            const detail = plan.detail ?? first?.detail ?? en('onboard.refusal.input');
+            if (plan.reason === 'scope_unreadable')
+                return fail('catalog_unreadable', detail);
+            if (plan.reason === 'env_catalog_present')
+                return fail('env_catalog_present', detail);
+            if (plan.reason === 'credential_unpaired')
+                return fail('credential_unpaired', detail);
+            return fail('input', detail);
+        }
+        const planned = plan.entries[0];
+        const nextEnv = own(plan.nextSettingsDoc, 'env');
+        return Object.freeze({
+            ok: true,
+            entryName: planned.name,
+            keyEnv: planned.keyEnv ?? '',
+            updatedExisting: planned.updatedExisting,
+            nextModelsDoc: plan.nextModelsDoc,
+            nextSettingsEnv: (isRecord(nextEnv) ? nextEnv : {}),
+            otherIssues: plan.otherIssues,
+        });
+    }
+    catch {
+        return fail('input', en('onboard.refusal.input'));
+    }
+}
+const CC_ENV = Object.freeze({ baseUrl: 'ANTHROPIC_BASE_URL', authToken: 'ANTHROPIC_AUTH_TOKEN', apiKey: 'ANTHROPIC_API_KEY' });
+const CC_MODEL_KEYS = Object.freeze(['ANTHROPIC_DEFAULT_OPUS_MODEL', 'ANTHROPIC_DEFAULT_FABLE_MODEL', 'ANTHROPIC_MODEL', 'ANTHROPIC_DEFAULT_SONNET_MODEL']);
+const numOf = (v) => (posInt(v) ? v : undefined);
+function jsonTextOf(text) {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function modelRowsOf(list) {
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    for (let i = 0; i < list.length && out.length < 256; i++) {
+        const m = own(list, String(i));
+        const id = strOf(own(m, 'id'));
+        if (id === undefined || out.some((x) => x.id === id))
+            continue;
+        const ctx = numOf(own(m, 'contextWindow')) ?? numOf(own(m, 'context_length'));
+        const max = numOf(own(m, 'maxTokens')) ?? numOf(own(m, 'max_tokens'));
+        out.push({ id, ...(ctx === undefined ? {} : { contextWindow: ctx }), ...(max === undefined ? {} : { maxTokens: max }) });
+    }
+    return out;
+}
+function ccEnvProfile(source, id, name, env, topModel, isCurrent) {
+    const baseUrl = strOf(own(env, CC_ENV.baseUrl));
+    if (baseUrl === undefined)
+        return undefined;
+    const key = strOf(own(env, CC_ENV.authToken)) ?? strOf(own(env, CC_ENV.apiKey));
+    const raw = CC_MODEL_KEYS.map((k) => strOf(own(env, k))).find((v) => v !== undefined) ?? strOf(topModel);
+    const models = raw === undefined ? [] : [{ id: raw.replace(/\[[0-9]+[kKmM]\]$/, '').trim() }].filter((m) => m.id !== '');
+    return Object.freeze({ source, id, name, baseUrl, api: 'anthropic-messages', ...(key === undefined ? {} : { apiKey: key }), models, ...(isCurrent === undefined ? {} : { isCurrent }) });
+}
+export function channelProfilesOf(source, data, env) {
+    const out = [];
+    try {
+        if (source === 'cc-switch') {
+            if (!Array.isArray(data))
+                return Object.freeze(out);
+            for (let i = 0; i < data.length && out.length < 256; i++) {
+                const row = own(data, String(i));
+                const id = strOf(own(row, 'id')) ?? (typeof own(row, 'id') === 'number' ? String(own(row, 'id')) : undefined);
+                if (id === undefined)
+                    continue;
+                const name = strOf(own(row, 'name')) ?? id;
+                const isCurrent = own(row, 'is_current') === 1 || own(row, 'is_current') === true;
+                const raw = own(row, 'settings_config');
+                const parsed = typeof raw === 'string' ? jsonTextOf(raw) : { ok: true, value: raw };
+                if (!parsed.ok)
+                    continue;
+                const cfg = parsed.value;
+                const base = strOf(own(cfg, 'baseUrl'));
+                const models = modelRowsOf(own(cfg, 'models'));
+                if (base !== undefined) {
+                    const key = strOf(own(cfg, 'apiKey')) ?? strOf(own(own(cfg, 'env'), CC_ENV.authToken)) ?? strOf(own(own(cfg, 'env'), CC_ENV.apiKey));
+                    out.push(Object.freeze({ source, id, name, baseUrl: base, api: 'anthropic-messages', ...(key === undefined ? {} : { apiKey: key }), models, isCurrent }));
+                    continue;
+                }
+                const p = ccEnvProfile(source, id, name, own(cfg, 'env'), own(cfg, 'model'), isCurrent);
+                if (p !== undefined)
+                    out.push(p);
+            }
+        }
+        else if (source === 'claude-settings') {
+            const p = ccEnvProfile(source, 'settings', 'Claude Code settings', own(data, 'env'), own(data, 'model'));
+            if (p !== undefined)
+                out.push(p);
+        }
+        else if (source === 'openclaw') {
+            const provs = own(own(data, 'models'), 'providers');
+            if (isRecord(provs)) {
+                for (const id of Object.keys(provs).slice(0, 256)) {
+                    const pv = own(provs, id);
+                    const base = strOf(own(pv, 'baseUrl'));
+                    if (base === undefined)
+                        continue;
+                    const key = strOf(own(pv, 'apiKey'));
+                    out.push(Object.freeze({ source, id, name: id, baseUrl: base, api: own(pv, 'api') === 'anthropic-messages' ? 'anthropic-messages' : 'openai-completions', ...(key === undefined ? {} : { apiKey: key }), models: modelRowsOf(own(pv, 'models')) }));
+                }
+            }
+        }
+        else if (source === 'hermes') {
+            const provs = own(data, 'providers');
+            if (isRecord(provs)) {
+                for (const id of Object.keys(provs).slice(0, 256)) {
+                    const pv = own(provs, id);
+                    const base = strOf(own(pv, 'api')) ?? strOf(own(pv, 'base_url'));
+                    if (base === undefined)
+                        continue;
+                    const keyEnvName = strOf(own(pv, 'key_env'));
+                    const key = strOf(own(pv, 'api_key')) ?? (keyEnvName === undefined ? undefined : strOf(env?.[keyEnvName]));
+                    const mdict = own(pv, 'models');
+                    const models = [];
+                    if (isRecord(mdict)) {
+                        for (const mid of Object.keys(mdict).slice(0, 256)) {
+                            const mv = own(mdict, mid);
+                            const ctx = numOf(own(mv, 'context_length'));
+                            const max = numOf(own(mv, 'max_tokens'));
+                            models.push({ id: mid, ...(ctx === undefined ? {} : { contextWindow: ctx }), ...(max === undefined ? {} : { maxTokens: max }) });
+                        }
+                    }
+                    const def = strOf(own(pv, 'default_model'));
+                    if (def !== undefined && !models.some((m) => m.id === def))
+                        models.push({ id: def });
+                    const transport = strOf(own(pv, 'transport'));
+                    out.push(Object.freeze({ source, id, name: id, baseUrl: base, api: transport !== undefined && /anthropic/i.test(transport) ? 'anthropic-messages' : 'openai-completions', ...(key === undefined ? {} : { apiKey: key }), models }));
+                }
+            }
+        }
+    }
+    catch {
+        return Object.freeze([...out]);
+    }
+    return Object.freeze(out);
+}
+function channelImportEntries(profile, modelIds, acceptUnverified) {
+    if (!isRecord(profile) || !Array.isArray(modelIds) || modelIds.length === 0)
+        return undefined;
+    const source = MODEL_POOL_CHANNEL_SOURCES.find((w) => w === own(profile, 'source'));
+    const baseUrl = strOf(own(profile, 'baseUrl'));
+    const api = own(profile, 'api');
+    const apiKey = strOf(own(profile, 'apiKey'));
+    const models = modelRowsOf(own(profile, 'models'));
+    if (source === undefined || baseUrl === undefined || !SETTINGS_MODEL_API_WORDS.some((w) => w === api))
+        return undefined;
+    const out = [];
+    for (let i = 0; i < modelIds.length; i++) {
+        const id = own(modelIds, String(i));
+        const row = models.find((m) => m.id === id);
+        if (row === undefined)
+            return undefined;
+        const fam = inferFamily(row.id);
+        const ctx = row.contextWindow ?? fam?.contextWindow;
+        const max = row.maxTokens ?? fam?.perModelCap;
+        out.push({
+            modelId: row.id,
+            api: api,
+            baseUrl,
+            credential: apiKey === undefined ? { kind: 'none' } : { kind: 'key', apiKey },
+            channel: source,
+            ...(strOf(own(profile, 'name')) === undefined ? {} : { label: strOf(own(profile, 'name')) }),
+            ...(ctx === undefined ? {} : { contextWindow: ctx }),
+            ...(max === undefined ? {} : { maxTokens: max }),
+            ...(acceptUnverified === true ? { acceptUnverified: true } : {}),
+        });
+    }
+    return out;
+}
+function seatEntrySpec(x, probe) {
+    return Object.freeze({
+        modelId: x.modelId,
+        api: x.api,
+        baseUrl: x.baseUrl,
+        credential: x.credential,
+        ...(x.label === undefined ? {} : { label: x.label }),
+        ...(x.vision === undefined ? {} : { vision: x.vision }),
+        ...(x.contextWindow === undefined ? {} : { contextWindow: x.contextWindow }),
+        ...(x.maxTokens === undefined ? {} : { maxTokens: x.maxTokens }),
+        ...(x.channel === undefined ? {} : { channel: x.channel }),
+        ...(x.acceptUnverified === true ? { acceptUnverified: true } : {}),
+        ...(probe === undefined ? {} : { probe }),
+    });
+}
+export function modelPoolEditOfSeat(edit, profiles, probes) {
+    try {
+        if (edit.kind === 'add') {
+            if (!Array.isArray(edit.entries))
+                return undefined;
+            const entries = edit.entries.map((x, i) => seatEntrySpec(x, Array.isArray(probes) ? probes[i] : undefined));
+            return Object.freeze({ kind: 'add', entries: Object.freeze(entries), ...(edit.defaultIndex === undefined ? {} : { defaultIndex: edit.defaultIndex }) });
+        }
+        if (own(edit, 'kind') !== 'importChannel')
+            return edit;
+        const source = own(edit, 'source');
+        const id = own(edit, 'profileId');
+        const profile = Array.isArray(profiles) ? profiles.find((p) => own(p, 'source') === source && own(p, 'id') === id) : undefined;
+        if (profile === undefined)
+            return undefined;
+        const modelIds = own(edit, 'modelIds');
+        const defaultIndex = own(edit, 'defaultIndex');
+        return Object.freeze({
+            kind: 'importChannel',
+            profile,
+            modelIds: Array.isArray(modelIds) ? [...modelIds] : [],
+            ...(typeof defaultIndex === 'number' ? { defaultIndex } : {}),
+            ...(own(edit, 'acceptUnverified') === true ? { acceptUnverified: true } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+const visionView = (r) => Object.freeze({ source: r.source, ...(r.value === undefined ? {} : { value: r.value }) });
+function providersOf() {
+    return Object.freeze(PROVIDER_PRESETS.map((p) => {
+        return Object.freeze({
+            id: p.id,
+            name: p.name,
+            baseUrl: p.baseUrl,
+            api: p.api,
+            authEnv: p.authEnv,
+            ...(p.consoleUrl === undefined ? {} : { consoleUrl: p.consoleUrl }),
+            ...(p.signupUrl === undefined ? (p.consoleUrl === undefined ? {} : { signupUrl: p.consoleUrl }) : { signupUrl: p.signupUrl }),
+            keyOptional: isLoopbackWireUrl(p.baseUrl),
+            models: Object.freeze(p.models.map((m) => Object.freeze({ id: m.id, contextWindow: m.contextWindow, maxTokens: m.maxTokens }))),
+        });
+    }));
+}
+export function modelPoolViewOf(readings) {
+    const env = envOf(own(readings, 'effectiveEnv'));
+    const mr = own(readings, 'models');
+    const sr = own(readings, 'userSettings');
+    const settingsRaw = own(sr, 'status') === 'loaded' ? own(sr, 'doc') : null;
+    const settings = settingsDocOf(settingsRaw);
+    const sdoc = settings.ok ? settings.doc : {};
+    const legacyTierSettings = sdoc['semaTierGroups'] !== undefined || sdoc['semaRosters'] !== undefined;
+    const status = own(mr, 'status');
+    const settingsEnv = settings.ok ? settings.env : {};
+    const empty = (catalog) => Object.freeze({
+        catalog,
+        completeness: catalog === 'unreadable' ? 'catalog_incomplete' : 'complete',
+        unreadableRows: 0,
+        entries: Object.freeze([]),
+        roles: Object.freeze([]),
+        tierGroups: Object.freeze([]),
+        defaultModel: catalog === 'absent' ? effectiveDefaultModelOf({ modelsDoc: null, userSettings: settingsRaw }) : unknownDefault(shadowDisclosuresOf(settingsRaw)),
+        legacyTierSettings,
+        orphanKeySlots: catalog === 'absent' ? orphanKeySlotsOf([], settingsEnv).length : 0,
+        envModels: Object.freeze(catalog === 'unreadable' ? [] : [env['MODEL_ID'], env['MODEL_CHEAP_ID']].filter((v) => typeof v === 'string' && v.trim() !== '')),
+        providers: providersOf(),
+    });
+    if (status === 'absent')
+        return empty('absent');
+    if (status !== 'loaded')
+        return empty('unreadable');
+    const raw = cloneDoc(own(mr, 'doc'));
+    if (raw === undefined)
+        return empty('unreadable');
+    const list = raw['models'];
+    if (list !== undefined && !Array.isArray(list))
+        return empty('unreadable');
+    const items = Array.isArray(list) ? list : [];
+    const { rows: good, unreadable } = catalogRowsOf(items);
+    const doc = { ...raw, models: good };
+    const def = effectiveDefaultModelOf({ modelsDoc: raw, userSettings: settingsRaw });
+    const blockDoc = withDefaultFolded(doc);
+    const groups = tierGroupsOf(raw).filter((g) => typeof g['name'] === 'string');
+    const active = typeof raw['activeTierGroup'] === 'string' ? raw['activeTierGroup'] : undefined;
+    const rosters = legacyRostersOf(sdoc);
+    const legacyTiers = legacyTierGroupsOf(sdoc);
+    const names = good.map((m) => entryName(m));
+    const entries = good.map((m) => {
+        const name = entryName(m);
+        const keyEnv = strOf(m['apiKeyEnv']);
+        const keyless = keyEnv === undefined && m['sealedApiKey'] === undefined;
+        const probeWord = strOf(m['semaProbe']);
+        const probeState = probeStateOf(probeWord);
+        const at = typeof m['semaProbeAt'] === 'number' && Number.isFinite(m['semaProbeAt']) ? m['semaProbeAt'] : undefined;
+        const visionIntent = typeof m['semaVision'] === 'boolean' ? m['semaVision'] : typeof m['vision'] === 'boolean' ? m['vision'] : undefined;
+        let issue;
+        try {
+            issue = isEnabled(m) ? onboardEntryCredentialIssue(m, env) : undefined;
+        }
+        catch {
+            issue = undefined;
+        }
+        const tiers = [];
+        for (const g of groups)
+            for (const [t, v] of Object.entries(bindingsOf(g)))
+                if (v === name)
+                    tiers.push(Object.freeze({ group: g['name'], tier: t }));
+        return Object.freeze({
+            name,
+            modelId: m['id'],
+            api: strOf(m['api']) ?? 'openai-completions',
+            baseUrl: typeof m['baseUrl'] === 'string' ? m['baseUrl'] : '',
+            enabled: isEnabled(m),
+            ...(strOf(m['semaLabel']) === undefined ? {} : { label: strOf(m['semaLabel']) }),
+            vision: visionView(resolveEntryVision({ modelId: m['id'], ...(visionIntent === undefined ? {} : { vision: visionIntent }) })),
+            keyless,
+            ...(keyEnv === undefined ? {} : { keyEnv }),
+            ...(posInt(m['contextWindow']) ? { contextWindow: m['contextWindow'] } : {}),
+            ...(posInt(m['maxTokens']) ? { maxTokens: m['maxTokens'] } : {}),
+            probe: probeState,
+            ...(probeState === 'unverified' && probeWord !== undefined ? { probeVerdict: probeWord } : {}),
+            ...(probeWord === undefined || at === undefined ? {} : { probedAt: at }),
+            isDefault: def.kind === 'named' && def.name === name,
+            tiers: Object.freeze(tiers),
+            deleteBlockers: Object.freeze(computeDeleteBlockers({ id: name, doc: blockDoc, rosters })),
+            deleteWarnings: Object.freeze(computeDeleteWarnings({ id: name, doc: doc, tierGroups: legacyTiers, survivingIds: names.filter((x) => x !== name) })),
+            ...(issue === undefined ? {} : { credentialIssue: issue }),
+        });
+    });
+    const roles = [];
+    if (isRecord(raw['roles'])) {
+        for (const [role, target] of Object.entries(raw['roles'])) {
+            if (!isRecord(target))
+                continue;
+            if (typeof target['model'] === 'string' && target['model'] !== '')
+                roles.push(Object.freeze({ role, model: target['model'] }));
+            else if (isRecord(target['select']))
+                roles.push(Object.freeze({ role, select: true }));
+        }
+    }
+    const tierGroups = groups.map((g) => {
+        const tiers = bindingsOf(g);
+        const resolved = {};
+        for (const t of Object.keys(tiers).length > 0 ? TIER_ORDER : []) {
+            const b = resolveTierBinding({ tiers }, t);
+            if (b !== undefined)
+                resolved[t] = b;
+        }
+        return Object.freeze({ name: g['name'], active: g['name'] === active, tiers: Object.freeze(tiers), resolved: Object.freeze(resolved) });
+    });
+    let activeTiers;
+    try {
+        activeTiers = SETTINGS_RESOLVE_ACTIVE_TIERS(raw);
+    }
+    catch {
+        activeTiers = undefined;
+    }
+    return Object.freeze({
+        catalog: 'read',
+        completeness: unreadable > 0 ? 'catalog_incomplete' : 'complete',
+        unreadableRows: unreadable,
+        entries: Object.freeze(entries),
+        roles: Object.freeze(roles),
+        tierGroups: Object.freeze(tierGroups),
+        ...(active !== undefined && activeTiers !== undefined ? { activeTierGroup: active } : {}),
+        defaultModel: def,
+        legacyTierSettings,
+        orphanKeySlots: items.every(isRecord) ? orphanKeySlotsOf(items, settingsEnv).length : 0,
+        envModels: Object.freeze(good.some(isEnabled) ? [] : [env['MODEL_ID'], env['MODEL_CHEAP_ID']].filter((v) => typeof v === 'string' && v.trim() !== '')),
+        providers: providersOf(),
+    });
+}
+export function modelPoolRowEditOf(row, action) {
+    try {
+        const name = own(row, 'name');
+        if (typeof name !== 'string' || name === '')
+            return undefined;
+        const kind = own(action, 'kind');
+        if (kind === 'remove')
+            return own(row, 'deleteBlockers') !== undefined && (row.deleteBlockers?.length ?? 0) > 0 ? undefined : Object.freeze({ kind: 'remove', name });
+        if (kind === 'setDefault')
+            return row.enabled === false || row.isDefault === true ? undefined : Object.freeze({ kind: 'setDefault', name });
+        if (kind === 'bindTier') {
+            const group = own(action, 'group');
+            const tier = own(action, 'tier');
+            return typeof group === 'string' && isTier(tier) ? Object.freeze({ kind: 'bindTier', group, tier, name }) : undefined;
+        }
+        if (kind === 'update') {
+            const a = action;
+            return Object.freeze({
+                kind: 'update',
+                name,
+                ...(a.label === undefined ? {} : { label: a.label }),
+                ...(a.vision === undefined ? {} : { vision: a.vision }),
+                ...(a.contextWindow === undefined ? {} : { contextWindow: a.contextWindow }),
+                ...(a.maxTokens === undefined ? {} : { maxTokens: a.maxTokens }),
+            });
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}