@sema-agent/client-core 0.111.0 → 0.112.1

package/dist/model/onboardJudgement.js

@@ -1,6 +1,8 @@
+import { inferFamily } from './providerPresets.js';
 import { ONBOARD_REFUSALS } from '../seatContract.js';
-import { joinRequestUrl, routeKeyOf } from '../coreValuePorts.js';
-import { applyProbeToEntry, probeModelLiveness, probeVerdictNotice } from '../modelCapabilityProbe.js';
+import { adjudicateModelRoute, joinRequestUrl, routeKeyOf } from '../coreValuePorts.js';
+import { settleWithinDeadline } from '../abortableSleep.js';
+import { probeModelLiveness, probeVerdictNotice } from '../modelCapabilityProbe.js';
 import { ownDataField } from '../ownKey.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 const field = (v, key) => {
@@ -57,6 +59,9 @@ function safeDecode(t) {
         return t;
     }
 }
+export function onboardKeyCarriedBy(text, key) {
+    return carriesKey(text, key);
+}
 function carriesKey(text, key) {
     if (key === undefined || key === '')
         return false;
@@ -69,6 +74,9 @@ function carriesKey(text, key) {
 function looksLikeSecret(val) {
     return /^(sk|ak|pk|rk)[-_]/i.test(val) || (val.length >= 20 && /[A-Za-z]/.test(val) && /[0-9]/.test(val) && /^[A-Za-z0-9._~+/=-]+$/.test(val));
 }
+export function onboardRedactKey(text, key) {
+    return redact(text, key);
+}
 function redact(text, key) {
     if (key === undefined || key === '')
         return text;
@@ -197,7 +205,71 @@ export async function probeModelEndpoint(target, deps) {
     });
     if (v.verdict === 'unreachable' && seen.redirected !== undefined)
         return out('unreachable', seen.redirected);
-    return out(v.verdict, probeDetailOf(v));
+    const firstOutputMs = v.verdict === 'ok' && typeof v.waitedMs === 'number' && Number.isFinite(v.waitedMs) && v.waitedMs >= 0 ? Math.round(v.waitedMs) : undefined;
+    const r = out(v.verdict, probeDetailOf(v));
+    return firstOutputMs === undefined ? r : Object.freeze({ ...r, firstOutputMs });
+}
+const DISCOVERY_MAX = 512;
+export async function discoverEndpointModels(target, deps) {
+    const apiKey = field(target, 'apiKey');
+    const key = typeof apiKey === 'string' && apiKey !== '' ? apiKey : undefined;
+    const fail = (verdict, detail) => Object.freeze({ ok: false, verdict, detail: capText(redact(detail, key?.trim() || undefined)) });
+    const baseUrl = field(target, 'baseUrl');
+    const api = field(target, 'api');
+    const auth = field(target, 'auth');
+    if (typeof baseUrl !== 'string' || (api !== 'anthropic-messages' && api !== 'openai-completions'))
+        return fail('other', en('onboard.probe.incomplete'));
+    const f = (field(deps, 'fetchImpl') ?? globalThis.fetch);
+    if (typeof f !== 'function')
+        return fail('unreachable', en('onboard.probe.noFetch'));
+    const root = baseUrl.trim();
+    let url;
+    try {
+        url = joinRequestUrl(root, 'models');
+    }
+    catch {
+        return fail('other', en('onboard.baseUrl.invalid'));
+    }
+    if (url === undefined)
+        return fail('other', en('onboard.probe.judgeAbsent'));
+    const t = field(deps, 'timeoutMs');
+    const budget = typeof t === 'number' && Number.isFinite(t) && t > 0 ? t : 10_000;
+    const headers = { ...(api === 'anthropic-messages' ? { 'anthropic-version': '2023-06-01' } : {}), ...keyHeaders(api, key, auth === 'bearer' || auth === 'x-api-key' ? auth : undefined) };
+    const settled = await settleWithinDeadline(budget, async (signal) => {
+        const res = await f(url, { method: 'GET', headers, redirect: 'manual', signal });
+        const redirected = redirectRefusal(res, url, key);
+        if (redirected !== undefined)
+            return fail('unreachable', redirected);
+        if (res.status === 401 || res.status === 403)
+            return fail('auth', en('model.pool.discover.status', { status: res.status }));
+        if (res.status < 200 || res.status >= 300)
+            return fail('other', en('model.pool.discover.status', { status: res.status }));
+        let body;
+        try {
+            body = JSON.parse(await res.text());
+        }
+        catch {
+            return fail('shape', en('model.pool.discover.notList'));
+        }
+        const data = field(body, 'data');
+        if (!Array.isArray(data))
+            return fail('shape', en('model.pool.discover.notList'));
+        const out = [];
+        for (let i = 0; i < data.length && out.length < DISCOVERY_MAX; i++) {
+            const id = field(field(data, String(i)), 'id');
+            if (typeof id !== 'string' || id.trim() === '' || id.length > 512 || carriesKey(id, key) || out.some((c) => c.id === id))
+                continue;
+            const fam = inferFamily(id);
+            const exact = fam !== undefined && fam.perModelCap !== undefined;
+            out.push(Object.freeze({ id, ...(exact ? { contextWindow: fam.contextWindow, maxTokens: fam.maxTokens } : {}) }));
+        }
+        return Object.freeze({ ok: true, candidates: Object.freeze(out) });
+    });
+    if (settled.kind === 'deadline')
+        return fail('unreachable', en('model.pool.discover.timeout'));
+    if (settled.kind === 'error')
+        return fail('unreachable', en('model.pool.discover.unreachable', { cause: settled.detail }));
+    return settled.value;
 }
 export function onboardWriteVerdict(verdict, acceptUnverified) {
     if (verdict === 'ok')
@@ -224,6 +296,9 @@ export function poolEntryNameOf(modelId, channel, taken) {
         candidate = `${name}-${channel}-${i}`;
     return candidate;
 }
+export function onboardEntryCredentialIssue(m, env) {
+    return entryCredentialIssue(m, env);
+}
 function entryCredentialIssue(m, env) {
     const name = typeof m['name'] === 'string' ? m['name'] : '?';
     if (m['sealedApiKey'] !== undefined && m['sealedApiKey'] !== null)
@@ -239,6 +314,19 @@ function entryCredentialIssue(m, env) {
     const api = typeof m['api'] === 'string' ? m['api'] : 'openai-completions';
     const rootKey = api === 'anthropic-messages' ? 'ANTHROPIC_BASE_URL' : 'MODEL_GATEWAY_BASEURL';
     const root = env[rootKey];
+    if (api !== 'anthropic-messages' && (typeof root !== 'string' || root.trim() === '')) {
+        let keyless;
+        try {
+            keyless = adjudicateModelRoute({ id: typeof m['id'] === 'string' ? m['id'] : name, baseUrl: base }, { source: 'absent' }, {});
+        }
+        catch {
+            keyless = undefined;
+        }
+        if (keyless === undefined)
+            return en('onboard.catalog.judgeAbsent', { name });
+        if (keyless.ok)
+            return undefined;
+    }
     let paired;
     try {
         const a = routeKeyOf(base);
@@ -262,142 +350,6 @@ function entryCredentialIssue(m, env) {
     const rootText = typeof root === 'string' && root !== '' ? `${rootKey} (${hostOf(root)})` : en('onboard.catalog.noRoot', { rootKey });
     return en('onboard.catalog.unpaired', { name, host: hostOf(base), root: rootText });
 }
-function migrateLegacyDefaultKey(doc) {
-    const legacy = doc['default'];
-    if (typeof legacy !== 'string' || legacy.length === 0)
-        return doc;
-    const { default: _legacy, ...rest } = doc;
-    void _legacy;
-    const prevRoles = rest['roles'];
-    const roles = prevRoles !== null && typeof prevRoles === 'object' && !Array.isArray(prevRoles) ? { ...prevRoles } : {};
-    roles['default'] = { model: legacy };
-    return { ...rest, roles };
-}
-export function onboardWritePlan(input) {
-    const rawKey = field(field(input, 'entry'), 'apiKey');
-    const planKey = typeof rawKey === 'string' && rawKey !== '' ? rawKey : undefined;
-    const say = (text) => redact(text, planKey);
-    const refuse = (refusal, detail) => Object.freeze({ ok: false, refusal, detail: say(detail) });
-    try {
-        if (input.engineMode === 'cloud')
-            return refuse('engine_is_remote', en('onboard.refusal.engineIsRemote'));
-        const rawDoc = input.modelsDoc;
-        if (rawDoc !== undefined && (rawDoc === null || typeof rawDoc !== 'object' || Array.isArray(rawDoc)))
-            return refuse('catalog_unreadable', en('onboard.plan.notObject'));
-        const doc = migrateLegacyDefaultKey(rawDoc === undefined ? {} : { ...rawDoc });
-        const rawModels = doc['models'];
-        if (rawModels !== undefined && !Array.isArray(rawModels))
-            return refuse('catalog_unreadable', en('onboard.plan.modelsNotList'));
-        const list = Array.isArray(rawModels) ? rawModels : [];
-        if (list.some((m) => m === null || typeof m !== 'object' || Array.isArray(m)))
-            return refuse('catalog_unreadable', en('onboard.plan.modelsItemNotObject'));
-        const models = list.map((m) => ({ ...m }));
-        const envModel = [input.effectiveEnv?.['MODEL_ID'], input.effectiveEnv?.['MODEL_CHEAP_ID']].find((v) => typeof v === 'string' && v.trim() !== '');
-        if (envModel !== undefined && !models.some((m) => m['enabled'] !== false)) {
-            return refuse('env_catalog_present', en('onboard.plan.envCatalogPresent', { model: envModel }));
-        }
-        const rawEnv = input.settingsEnv;
-        if (rawEnv !== undefined && (rawEnv === null || typeof rawEnv !== 'object' || Array.isArray(rawEnv)))
-            return refuse('catalog_unreadable', en('onboard.plan.envNotObject'));
-        const prevEnv = rawEnv === undefined ? {} : { ...rawEnv };
-        const e = input.entry;
-        const isShellSlot = (ref) => typeof ref === 'string' && ref.startsWith(KEY_SLOT_PREFIX) && typeof prevEnv[ref] === 'string';
-        const targetKey = routeKeyOf(e.baseUrl);
-        if (targetKey === undefined)
-            return refuse('credential_unpaired', en('onboard.catalog.judgeAbsent', { name: e.modelId }));
-        const sameTarget = (m) => m['id'] === e.modelId && m['api'] === e.api && typeof m['baseUrl'] === 'string' && routeKeyOf(m['baseUrl']) === targetKey;
-        const existingIdx = models.findIndex((m) => sameTarget(m) && m['enabled'] !== false && m['sealedApiKey'] === undefined && (m['apiKeyEnv'] === undefined || isShellSlot(m['apiKeyEnv'])));
-        const taken = new Set(models.map((m) => (typeof m['name'] === 'string' ? m['name'] : '')).filter((n) => n !== ''));
-        const name = existingIdx >= 0 ? String(models[existingIdx]['name']) : poolEntryNameOf(e.modelId, e.channel, taken);
-        const existingRef = existingIdx >= 0 ? models[existingIdx]['apiKeyEnv'] : undefined;
-        const sharedByOther = typeof existingRef === 'string' &&
-            models.some((m, i) => i !== existingIdx && typeof m['apiKeyEnv'] === 'string' && m['apiKeyEnv'].toUpperCase() === existingRef.toUpperCase());
-        let keyEnv;
-        if (isShellSlot(existingRef) && !sharedByOther) {
-            keyEnv = existingRef;
-        }
-        else {
-            const used = new Set();
-            for (const m of models)
-                if (typeof m['apiKeyEnv'] === 'string')
-                    used.add(m['apiKeyEnv'].toUpperCase());
-            for (const k of Object.keys(prevEnv))
-                used.add(k.toUpperCase());
-            for (const [k, v] of Object.entries(input.effectiveEnv ?? {}))
-                if (typeof v === 'string')
-                    used.add(k.toUpperCase());
-            const baseSlot = keyEnvNameForEntry(name);
-            keyEnv = baseSlot;
-            for (let i = 2; used.has(keyEnv.toUpperCase()); i++)
-                keyEnv = `${baseSlot}_${i}`;
-        }
-        if (carriesKey(name, e.apiKey) || carriesKey(keyEnv, e.apiKey))
-            return refuse('input', en('onboard.input.keyInFields'));
-        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,
-            contextWindow: typeof base['contextWindow'] === 'number' ? base['contextWindow'] : e.contextWindow,
-            maxTokens: typeof base['maxTokens'] === 'number' ? base['maxTokens'] : e.maxTokens,
-            apiKeyEnv: keyEnv,
-            semaChannel: typeof base['semaChannel'] === 'string' ? base['semaChannel'] : e.channel,
-            semaLabel: typeof base['semaLabel'] === 'string' ? base['semaLabel'] : e.providerName,
-            semaProbe: input.probe.verdict,
-            semaProbeAt: input.now,
-        };
-        if (input.thinking !== undefined) {
-            const probed = applyProbeToEntry({ ...(typeof entry['reasoning'] === 'boolean' ? { reasoning: entry['reasoning'] } : {}), ...(entry['compat'] !== undefined ? { compat: entry['compat'] } : {}) }, input.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 envView = { ...input.effectiveEnv, [keyEnv]: e.apiKey };
-        const issue = entryCredentialIssue(entry, envView);
-        if (issue !== undefined)
-            return refuse('credential_unpaired', issue);
-        if (existingIdx >= 0)
-            models[existingIdx] = entry;
-        else
-            models.push(entry);
-        const nextDoc = { ...doc, models };
-        if (input.makeDefault) {
-            const prevRoles = doc['roles'];
-            const roles = prevRoles !== null && typeof prevRoles === 'object' && !Array.isArray(prevRoles) ? { ...prevRoles } : {};
-            roles['default'] = { model: name };
-            nextDoc['roles'] = roles;
-        }
-        const otherIssues = [];
-        for (const m of models) {
-            if (m['enabled'] === false || m['name'] === name)
-                continue;
-            const other = entryCredentialIssue(m, envView);
-            if (other !== undefined) {
-                otherIssues.push(Object.freeze({ name: typeof m['name'] === 'string' ? m['name'] : '?', modelId: typeof m['id'] === 'string' ? m['id'] : '?', issue: say(other) }));
-            }
-        }
-        return Object.freeze({
-            ok: true,
-            entryName: name,
-            keyEnv,
-            updatedExisting: existingIdx >= 0,
-            nextModelsDoc: nextDoc,
-            nextSettingsEnv: { ...prevEnv, [keyEnv]: e.apiKey },
-            otherIssues: Object.freeze(otherIssues),
-        });
-    }
-    catch {
-        return refuse('input', en('onboard.refusal.input'));
-    }
-}
 const REFUSAL_KEYS = {
     input: 'onboard.refusal.input',
     probe_failed: 'onboard.refusal.probeFailed',

package/dist/modelConfigGapNotice.d.ts

@@ -0,0 +1,20 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+type ModelConfigPartTuple = readonly ['model', 'gateway-url', 'api-key'];
+export type ModelConfigPart = ModelConfigPartTuple[number];
+export type ModelConfigKeyChannel = 'anthropic';
+export interface ModelConfigGap {
+    readonly parts: readonly ModelConfigPart[];
+    readonly keyChannel?: ModelConfigKeyChannel;
+    readonly catalogEntries?: number;
+}
+export type ModelConfigGapNotice = {
+    readonly kind: 'gap';
+    readonly head: string;
+    readonly detail: string;
+} | {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'malformed';
+};
+export declare function modelConfigGapNotice(missing: ModelConfigGap, lang?: UiLanguage): ModelConfigGapNotice;
+export {};

package/dist/modelConfigGapNotice.js

@@ -0,0 +1,102 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { guardedRead, ownDataField } from './ownKey.js';
+function partOrder() {
+    return ['model', 'gateway-url', 'api-key'];
+}
+function isPart(v) {
+    return v === 'model' || v === 'gateway-url' || v === 'api-key';
+}
+const MALFORMED = Object.freeze({ kind: 'malformed' });
+const NONE = Object.freeze({ kind: 'none' });
+function readGap(missing) {
+    try {
+        if (missing === null || typeof missing !== 'object' || Array.isArray(missing))
+            return undefined;
+        const raw = ownDataField(missing, 'parts');
+        if (!Array.isArray(raw))
+            return undefined;
+        const order = partOrder();
+        const length = ownDataField(raw, 'length');
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > order.length)
+            return undefined;
+        const present = new Set();
+        for (let i = 0; i < length; i++) {
+            const word = ownDataField(raw, String(i));
+            if (!isPart(word) || present.has(word))
+                return undefined;
+            present.add(word);
+        }
+        const parts = order.filter((p) => present.has(p));
+        const channel = guardedRead(() => ownDataField(missing, 'keyChannel'));
+        const count = guardedRead(() => ownDataField(missing, 'catalogEntries'));
+        return {
+            parts,
+            anthropicKey: channel === 'anthropic' && present.has('api-key'),
+            entries: typeof count === 'number' && Number.isSafeInteger(count) && count >= 1 ? count : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+const HEAD_KEYS = Object.freeze({
+    model: 'model.configGap.head.model',
+    gatewayUrl: 'model.configGap.head.gatewayUrl',
+    apiKey: 'model.configGap.head.apiKey',
+    anthropicKey: 'model.configGap.head.anthropicKey',
+    incomplete: 'model.configGap.head.incomplete',
+});
+function headKeyOf(r) {
+    if (r.parts.includes('model'))
+        return HEAD_KEYS.model;
+    if (r.parts.includes('gateway-url'))
+        return r.parts.includes('api-key') ? HEAD_KEYS.incomplete : HEAD_KEYS.gatewayUrl;
+    return r.anthropicKey ? HEAD_KEYS.anthropicKey : HEAD_KEYS.apiKey;
+}
+function itemRef(part, anthropicKey) {
+    switch (part) {
+        case 'model':
+            return msg('model.configGap.item.model');
+        case 'gateway-url':
+            return msg('model.configGap.item.gatewayUrl');
+        case 'api-key':
+            return msg(anthropicKey ? 'model.configGap.item.anthropicKey' : 'model.configGap.item.apiKey');
+    }
+}
+function leadRef(first, second, third, anthropicKey) {
+    const a = itemRef(first, anthropicKey);
+    if (second === undefined)
+        return msg('model.configGap.lead.one', { a });
+    const b = itemRef(second, anthropicKey);
+    if (third === undefined)
+        return msg('model.configGap.lead.two', { a, b });
+    return msg('model.configGap.lead.three', { a, b, c: itemRef(third, anthropicKey) });
+}
+function reasonRef(r) {
+    if (r.parts.includes('model'))
+        return msg('model.configGap.reason.noModel');
+    const n = r.entries;
+    if (n === undefined)
+        return undefined;
+    if (r.anthropicKey)
+        return n === 1 ? msg('model.configGap.reason.anthropicCatalog.one') : msg('model.configGap.reason.anthropicCatalog.other', { count: n });
+    if (r.parts.includes('gateway-url'))
+        return n === 1 ? msg('model.configGap.reason.gatewayCatalog.one') : msg('model.configGap.reason.gatewayCatalog.other', { count: n });
+    return undefined;
+}
+export function modelConfigGapNotice(missing, lang) {
+    const r = readGap(missing);
+    if (r === undefined)
+        return MALFORMED;
+    const [first, second, third] = r.parts;
+    if (first === undefined)
+        return NONE;
+    const lead = leadRef(first, second, third, r.anthropicKey);
+    const reason = reasonRef(r);
+    const detail = reason === undefined ? lead : msg('model.configGap.detail.withReason', { missing: lead, reason });
+    return Object.freeze({
+        kind: 'gap',
+        head: renderMessage(msg(headKeyOf(r)), lang),
+        detail: renderMessage(detail, lang),
+    });
+}

package/dist/modsKernelIdentity.js

@@ -1,4 +1,5 @@
 import { KERNEL_CONTRACT_VERSION, MOD_EVENT_TABLE } from '@sema-agent/mods-kernel';
+import { sha256BytesHex } from './sha256Bytes.js';
 const MAX_DEPTH = 16;
 const MAX_NODES = 100_000;
 function canonical(v, depth, budget) {
@@ -35,52 +36,6 @@ function canonical(v, depth, budget) {
     }
     throw new TypeError('modsKernelIdentity: the event table holds a value that is not plain data');
 }
-function sha256Hex(msg) {
-    const k = [
-        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-    ];
-    const h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-    const len = msg.length;
-    const padded = new Uint8Array(((len + 8) >>> 6) * 64 + 64);
-    padded.set(msg);
-    padded[len] = 0x80;
-    const view = new DataView(padded.buffer);
-    view.setUint32(padded.length - 8, Math.floor(len / 0x20000000));
-    view.setUint32(padded.length - 4, (len << 3) >>> 0);
-    const w = new Array(64).fill(0);
-    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
-    for (let off = 0; off < padded.length; off += 64) {
-        for (let t = 0; t < 16; t++)
-            w[t] = view.getUint32(off + t * 4);
-        for (let t = 16; t < 64; t++) {
-            const x = w[t - 15] ?? 0;
-            const y = w[t - 2] ?? 0;
-            const s0 = rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3);
-            const s1 = rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10);
-            w[t] = ((w[t - 16] ?? 0) + s0 + (w[t - 7] ?? 0) + s1) | 0;
-        }
-        let [a, b, c, d, e, f, g, hh] = h;
-        for (let t = 0; t < 64; t++) {
-            const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + (k[t] ?? 0) + (w[t] ?? 0)) | 0;
-            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
-            hh = g;
-            g = f;
-            f = e;
-            e = (d + t1) | 0;
-            d = c;
-            c = b;
-            b = a;
-            a = (t1 + t2) | 0;
-        }
-        const next = [a, b, c, d, e, f, g, hh];
-        for (let i = 0; i < 8; i++)
-            h[i] = ((h[i] ?? 0) + (next[i] ?? 0)) | 0;
-    }
-    return h.map((x) => (x >>> 0).toString(16).padStart(8, '0')).join('');
-}
 export function modsKernelIdentity(kernel = { KERNEL_CONTRACT_VERSION, MOD_EVENT_TABLE }) {
     try {
         if (typeof kernel !== 'object' || kernel === null)
@@ -93,7 +48,7 @@ export function modsKernelIdentity(kernel = { KERNEL_CONTRACT_VERSION, MOD_EVENT
         if (typeof table !== 'object' || table === null || Array.isArray(table)) {
             throw new TypeError('modsKernelIdentity: the source carries no readable event table');
         }
-        return { contractVersion, tableDigest: sha256Hex(new TextEncoder().encode(canonical(table, 0, { nodes: 0 }))) };
+        return { contractVersion, tableDigest: sha256BytesHex(new TextEncoder().encode(canonical(table, 0, { nodes: 0 }))) };
     }
     catch (e) {
         if (e instanceof TypeError)

package/dist/notifications.js

@@ -1,4 +1,5 @@
 import { hostEnv } from './hostEnv.js';
+import { planReviewOutcomeCauseOf } from './planReviewOutcomeCause.js';
 import { unrefTimer } from './unrefTimer.js';
 import { clearEnginePanelTaskResidentByWire, publishEngineAgentPanelEvent, } from './engineAgentPanelStore.js';
 import { panelEndFact } from './panelReduce.js';
@@ -432,21 +433,22 @@ export function enqueuePlanReviewOutcome(value, meta) {
         priority: 'later',
         isMeta: true,
         workload: 'plan-review',
-        ...(meta !== undefined
-            ? {
-                _sema_planReviewOutcome: Object.freeze({
-                    taskId: meta.taskId,
-                    dispatchNo: meta.dispatchNo,
-                    decision: meta.decision,
-                    effect: meta.effect,
-                    ...(meta.effect === 'still_parked' && meta.cause === 'stored_form_unsupported' ? { cause: meta.cause } : {}),
-                    ...(questionId !== undefined ? { questionId } : {}),
-                }),
-            }
-            : {}),
+        ...(meta !== undefined ? { _sema_planReviewOutcome: planReviewOutcomeRefrozen(meta, questionId) } : {}),
     });
     return true;
 }
+function planReviewOutcomeRefrozen(meta, questionId) {
+    const effect = meta.effect;
+    const cause = planReviewOutcomeCauseOf(effect, meta.cause);
+    return Object.freeze({
+        taskId: meta.taskId,
+        dispatchNo: meta.dispatchNo,
+        decision: meta.decision,
+        effect,
+        ...(cause !== undefined ? { cause } : {}),
+        ...(questionId !== undefined ? { questionId } : {}),
+    });
+}
 export function resupplyTruncatedSentence(facts, lang) {
     try {
         const f = resupplyTruncatedFactsOf(facts);

package/dist/ownKey.d.ts

@@ -75,6 +75,7 @@ export interface SampledRecord {
 export declare function ownSnapshotWhenTyped<V>(value: V, word: string): SampledJson;
 export declare function ownSnapshotTyped<T extends object>(value: T): T | undefined;
 export declare function ownSnapshotRecord<V>(value: V): SampledRecord | undefined;
+export declare function ownSnapshotRecordFaithful<V>(value: V): SampledRecord | undefined;
 export declare function workflowCompletionExtrasOf(c: object): {
     completionId?: string;
     diagnostics?: string;

package/dist/ownKey.js

@@ -291,6 +291,7 @@ export function promptManifestIdentityOf(raw) {
     }
 }
 const SAMPLED = new WeakSet();
+const LOSSY = new WeakSet();
 const SAMPLE_MAX_DEPTH = 256;
 export function isOwnSnapshot(v) {
     return isBranded(v);
@@ -311,7 +312,7 @@ function snapshotOf(value) {
     if (typeof value === 'object' && value !== null) {
         if (SAMPLED.has(value))
             return value;
-        return sampleObject(value, 0, { done: new Map(), path: new Set(), seen: new Set(), rework: 0, depthCuts: 0 });
+        return sampleObject(value, 0, { done: new Map(), path: new Set(), seen: new Set(), rework: 0, depthCuts: 0, lost: 0 });
     }
     return samplePrimitive(value);
 }
@@ -342,6 +343,10 @@ export function ownSnapshotTyped(value) {
 export function ownSnapshotRecord(value) {
     return recordOf(value);
 }
+export function ownSnapshotRecordFaithful(value) {
+    const s = recordOf(value);
+    return s === undefined || LOSSY.has(s) ? undefined : s;
+}
 function recordOf(value) {
     const s = snapshotOf(value);
     return typeof s === 'object' && s !== null && !Array.isArray(s) ? s : undefined;
@@ -357,19 +362,29 @@ function sampleValue(v, depth, run) {
 }
 function sampleObject(src, depth, run) {
     const hit = run.done.get(src);
-    if (hit !== undefined)
+    if (hit !== undefined) {
+        if (hit === null || LOSSY.has(hit))
+            run.lost++;
         return hit ?? undefined;
-    if (SAMPLED.has(src))
+    }
+    if (SAMPLED.has(src)) {
+        if (LOSSY.has(src))
+            run.lost++;
         return src;
-    if (run.path.has(src))
+    }
+    if (run.path.has(src)) {
+        run.lost++;
         return undefined;
+    }
     if (depth >= SAMPLE_MAX_DEPTH) {
         run.depthCuts++;
+        run.lost++;
         return undefined;
     }
     if (run.seen.has(src)) {
         if (++run.rework > SAMPLE_MAX_REWORK) {
             run.depthCuts++;
+            run.lost++;
             return undefined;
         }
     }
@@ -384,10 +399,12 @@ function sampleObject(src, depth, run) {
     }
     catch {
         run.done.set(src, null);
+        run.lost++;
         return undefined;
     }
     run.path.add(src);
     const cutsBefore = run.depthCuts;
+    const lostBefore = run.lost;
     try {
         const rec = {};
         const arr = [];
@@ -409,18 +426,29 @@ function sampleObject(src, depth, run) {
             const index = isArray ? arrayIndexOfKey(k) : undefined;
             if (isArray && index === undefined)
                 continue;
-            if (index !== undefined && index >= SAMPLE_MAX_INDEX)
+            if (index !== undefined && index >= SAMPLE_MAX_INDEX) {
+                run.lost++;
                 continue;
+            }
             if (index !== undefined && index + 1 > tail)
                 tail = index + 1;
             const d = guardedRead(() => Object.getOwnPropertyDescriptor(src, k));
-            if (d === undefined)
+            if (d === undefined) {
+                run.lost++;
                 continue;
-            if (d.enumerable !== true || !Object.hasOwn(d, 'value'))
+            }
+            if (d.enumerable !== true)
+                continue;
+            if (!Object.hasOwn(d, 'value')) {
+                run.lost++;
                 continue;
+            }
             const child = sampleValue(d.value, depth + 1, run);
-            if (child === undefined)
+            if (child === undefined) {
+                if (typeof d.value === 'bigint')
+                    run.lost++;
                 continue;
+            }
             if (index !== undefined) {
                 Object.defineProperty(arr, index, { value: child, writable: true, enumerable: true, configurable: true });
                 if (index + 1 > good)
@@ -431,12 +459,16 @@ function sampleObject(src, depth, run) {
         }
         if (isArray) {
             const want = Math.max(good, Math.min(Math.max(tail, declared), good + SAMPLE_MAX_TRAILING_HOLES));
+            if (Math.max(tail, declared) > want)
+                run.lost++;
             if (arr.length < want)
                 arr.length = want;
         }
         const out = isArray ? arr : rec;
         Object.freeze(out);
         SAMPLED.add(out);
+        if (run.lost !== lostBefore)
+            LOSSY.add(out);
         if (run.depthCuts === cutsBefore)
             run.done.set(src, out);
         return out;

package/dist/permissionsDeclaration.d.ts

@@ -1,5 +1,6 @@
 import { type CoreValuePortName } from './coreValuePorts.js';
 import { type PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 declare const SETTINGS_SOURCE_TIERS: Readonly<{
     readonly policySettings: "managed";
     readonly flagSettings: "global";
@@ -118,5 +119,5 @@ export interface PermissionsAllowKeptFacts {
     readonly managedPolicyFetch?: 'in_progress' | 'failed' | 'unknown';
     readonly where?: string;
 }
-export declare function permissionsAllowKeptNotice(report: Pick<PermissionsDeclarationReport, 'kept'>, settingsRead: 'clean' | 'partial' | 'unreadable', facts?: PermissionsAllowKeptFacts): string | undefined;
+export declare function permissionsAllowKeptNotice(report: Pick<PermissionsDeclarationReport, 'kept'>, settingsRead: 'clean' | 'partial' | 'unreadable', facts?: PermissionsAllowKeptFacts, lang?: UiLanguage): string | undefined;
 export {};