@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/model/onboardJudgement.d.ts

@@ -50,6 +50,7 @@ export type OnboardWriteVerdict = {
     readonly refusal: 'probe_failed' | 'probe_unverified';
 };
 export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict, acceptUnverified?: boolean): OnboardWriteVerdict;
+export declare const KEY_SLOT_PREFIX = "SEMA_MODEL_KEY_";
 export declare function keyEnvNameForEntry(entryName: string): string;
 export declare function poolEntryNameOf(modelId: string, channel: string, taken: ReadonlySet<string>): string;
 export interface OnboardPlanEntry {

package/dist/model/onboardJudgement.js

@@ -206,7 +206,7 @@ export function onboardWriteVerdict(verdict, acceptUnverified) {
         return Object.freeze({ write: false, refusal: 'probe_failed' });
     return acceptUnverified === true ? Object.freeze({ write: true, unverified: true }) : Object.freeze({ write: false, refusal: 'probe_unverified' });
 }
-const KEY_SLOT_PREFIX = 'SEMA_MODEL_KEY_';
+export const KEY_SLOT_PREFIX = 'SEMA_MODEL_KEY_';
 export function keyEnvNameForEntry(entryName) {
     const base = String(entryName).toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'ENTRY';
     return `${KEY_SLOT_PREFIX}${base}`;

package/dist/model/subagentModelWord.js

@@ -8,7 +8,7 @@ function ownData(v, key) {
         return undefined;
     try {
         const d = Object.getOwnPropertyDescriptor(v, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;
@@ -74,7 +74,7 @@ function ownSlot(v, key) {
         const d = Object.getOwnPropertyDescriptor(v, key);
         if (d === undefined)
             return { kind: 'absent' };
-        return 'value' in d ? { kind: 'value', value: d.value } : { kind: 'unreadable' };
+        return Object.hasOwn(d, 'value') ? { kind: 'value', value: d.value } : { kind: 'unreadable' };
     }
     catch {
         return { kind: 'unreadable' };

package/dist/modelCapabilityProbe.d.ts

@@ -1,4 +1,5 @@
 import type { ModelApiWord } from './model/providerPresets.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface OpenAICompletionsProbeBody {
     model: string;
     messages: ReadonlyArray<{
@@ -129,5 +130,5 @@ export interface ProbeVerdictFacts {
 }
 export declare function probeVerdictNotice(facts: ProbeVerdictFacts | null | undefined, ctx?: {
     readonly modelName?: string;
-}): ProbeVerdictNotice;
+}, lang?: UiLanguage): ProbeVerdictNotice;
 export {};

package/dist/modelCapabilityProbe.js

@@ -1,7 +1,9 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { abortableSleep } from './abortableSleep.js';
+import { causeSlotProtected, walkCauseChain } from './engineWireFor.js';
 import { readThrownSlot } from './wireFailureShape.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const THINKING_FORMATS = Object.freeze([
     'openai',
     'openrouter',
@@ -466,18 +468,17 @@ function nearestFromCatalogText(text, modelId) {
 }
 function unwrapFetchCause(e) {
     const parts = [];
-    let cur = e;
-    for (let i = 0; i < 4 && cur !== null && typeof cur === 'object'; i++) {
-        const code = readThrownSlot(cur, 'code');
-        const message = readThrownSlot(cur, 'message');
+    walkCauseChain(e, (layer) => {
+        const code = readThrownSlot(layer, 'code');
+        const message = readThrownSlot(layer, 'message');
         const c = typeof code === 'string' && code !== '' ? code : undefined;
         const m = typeof message === 'string' && message !== '' ? message : undefined;
         if (c !== undefined)
             parts.push(m !== undefined && m !== c ? `${c} ${m}` : c);
         else if (m !== undefined)
             parts.push(m);
-        cur = readThrownSlot(cur, 'cause');
-    }
+        return undefined;
+    }, causeSlotProtected);
     if (parts.length === 0 && typeof e === 'string')
         parts.push(e);
     return [...new Set(parts)].join(' ← ');
@@ -698,7 +699,7 @@ function probeSeconds(ms) {
     return `${Number.isInteger(sec) ? sec : sec.toFixed(1)}s`;
 }
 const readFacts = (o, key) => guardedRead(() => readOwnDataValue(o, key));
-export function probeVerdictNotice(facts, ctx) {
+export function probeVerdictNotice(facts, ctx, lang) {
     const rawWord = readFacts(facts, 'verdict');
     const word = typeof rawWord === 'string' && PROBE_VERDICTS.includes(rawWord) ? rawWord : 'other';
     const rawStatus = readFacts(facts, 'httpStatus');
@@ -713,31 +714,31 @@ export function probeVerdictNotice(facts, ctx) {
     let recourse;
     switch (word) {
         case 'ok':
-            line = `The model answered${waited === undefined ? '' : ` — first token after ${probeSeconds(waited)}`}`;
+            line = renderMessage(waited === undefined ? msg('model.probe.verdict.ok') : msg('model.probe.verdict.okWaited', { time: probeSeconds(waited) }), lang);
             break;
         case 'auth':
-            line = `The model service rejected the API key${http}`;
+            line = renderMessage(msg('model.probe.verdict.auth', { http }), lang);
             recourse = 'check_credentials';
             break;
         case 'unreachable':
-            line = `Could not reach the model service${waited === undefined ? '' : ` — no response within ${probeSeconds(waited)}`}`;
+            line = renderMessage(waited === undefined ? msg('model.probe.verdict.unreachable') : msg('model.probe.verdict.unreachableWaited', { time: probeSeconds(waited) }), lang);
             break;
         case 'model':
-            line = `The model service does not recognise this model id${http}`;
+            line = renderMessage(msg('model.probe.verdict.model', { http }), lang);
             break;
         case 'shape':
-            line = `This address does not offer the expected interface${http} — check the API shape`;
+            line = renderMessage(msg('model.probe.verdict.shape', { http }), lang);
             break;
         case 'busy':
-            line = `The model service is busy right now${http} — retry later or switch model`;
+            line = renderMessage(msg('model.probe.verdict.busy', { http }), lang);
             recourse = 'switch_model';
             break;
         case 'no_token':
-            line = `The model service answered but sent no token${waited === undefined ? '' : ` within ${probeSeconds(waited)}`} — it may be overloaded`;
+            line = renderMessage(waited === undefined ? msg('model.probe.verdict.noToken') : msg('model.probe.verdict.noTokenWaited', { time: probeSeconds(waited) }), lang);
             recourse = 'switch_model';
             break;
         case 'other':
-            line = `The model service gave an unexpected answer${http}`;
+            line = renderMessage(msg('model.probe.verdict.other', { http }), lang);
             break;
     }
     return Object.freeze(recourse === undefined ? { line: `${prefix}${line}` } : { line: `${prefix}${line}`, recourse });

package/dist/modelIdentityResolvability.d.ts

@@ -12,11 +12,16 @@ export type ModelIdentityLanes = {
     [L in ModelIdentityLane]: ModelIdentityLaneReading;
 };
 export type EngineAnswerObservation = 'answered' | 'not_observed' | 'unreachable';
+export type EngineCatalogAdoptionReading = 'absent' | 'refused' | 'undetermined';
 export interface LocalEngineModelIdentityReading {
     engine: 'local';
     lanes: ModelIdentityLanes;
     engineAnswer?: EngineAnswerObservation;
-    engineAcceptsCatalogDefault?: boolean;
+    catalogAdoption?: EngineCatalogAdoptionReading;
+    catalogFacts?: {
+        readonly listed?: number;
+        readonly shapeRefused?: boolean;
+    };
     routeGap?: ModelRouteGapReading;
 }
 export type ModelRouteGapReading = 'endpoint_missing' | 'lane_credential_missing' | 'none';
@@ -28,6 +33,12 @@ export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngin
 export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
 export type ModelSetupDecision = 'offer_setup' | 'offer_route_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'explain_route_unconfigurable' | 'proceed';
 export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
+export interface ModelIdentityCatalogDeviation {
+    readonly kind: 'catalog_lane_overridden_by_facts';
+    readonly reported: ModelIdentityLaneReading | 'unusable';
+    readonly derived: 'partial' | 'absent';
+}
+export declare function modelIdentityCatalogDeviationOf(reading: ModelIdentityReading): ModelIdentityCatalogDeviation | undefined;
 export declare function modelRouteGapSentence(lane: ModelIdentityLane, gap: ModelRouteGapReading, lang?: UiLanguage): string | undefined;
 export declare function modelRouteGapFact(gap: ModelRouteGapReading, lang?: UiLanguage): string | undefined;
 export declare function modelIdentityDetail(reading: ModelIdentityReading): string;

package/dist/modelIdentityResolvability.js

@@ -1,6 +1,7 @@
 import { engineCapsLandingOf } from './engineCapsCache.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
 function laneOrder() {
     return ['processEnv', 'settingsEnv', 'modelCatalogFile', 'followedSettingsFile', 'followedProviderEnv'];
 }
@@ -22,15 +23,37 @@ function laneState(lanes, lane) {
     const v = hit.v;
     return v === 'complete' || v === 'partial' || v === 'absent' || v === 'unreadable' ? v : 'unusable';
 }
-function catalogDefaultEvidence(catalog, accepts) {
+function catalogDefaultEvidence(catalog, adoption) {
     const _evidencePin = true;
     void _evidencePin;
-    return catalog === 'complete' && accepts === true ? { catalog, engineAccepts: accepts } : undefined;
+    return catalog === 'complete' && adoption !== 'refused' ? { catalog, adoption: adoption ?? 'not_reported' } : undefined;
 }
 function routeGapOf(reading) {
     const v = own(reading, 'routeGap')?.v;
     return v === 'endpoint_missing' || v === 'lane_credential_missing' || v === 'none' ? v : undefined;
 }
+function catalogAdoptionOf(reading) {
+    const v = own(reading, 'catalogAdoption')?.v;
+    return v === 'absent' || v === 'refused' || v === 'undetermined' ? v : undefined;
+}
+const ownDataValue = (o, key) => guardedRead(() => readOwnDataValue(o, key));
+function isPlainObjectSafe(v) {
+    try {
+        return isPlainObject(v);
+    }
+    catch {
+        return false;
+    }
+}
+function catalogFactsDerivedOf(reading) {
+    const facts = ownDataValue(reading, 'catalogFacts');
+    if (!isPlainObjectSafe(facts) || ownDataValue(facts, 'shapeRefused') !== true)
+        return undefined;
+    if (catalogAdoptionOf(reading) !== 'refused')
+        return undefined;
+    const listed = ownDataValue(facts, 'listed');
+    return typeof listed === 'number' && Number.isSafeInteger(listed) && listed > 0 ? 'partial' : 'absent';
+}
 function analyse(reading) {
     try {
         if (!isPlainObject(reading))
@@ -47,29 +70,32 @@ function analyse(reading) {
         const lanesHit = own(reading, 'lanes')?.v;
         const order = laneOrder();
         if (!isPlainObject(lanesHit)) {
-            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogUnconfirmed: null, catalogRefused: false };
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogRefused: false };
         }
         const partial = [];
         const unreadable = [];
         const unreported = [];
         const unusable = [];
         let catalogRefused = false;
-        let catalogUnconfirmed = null;
         for (const lane of order) {
+            if (lane === 'modelCatalogFile') {
+                const factsDerived = catalogFactsDerivedOf(reading);
+                if (factsDerived !== undefined) {
+                    if (factsDerived === 'partial') {
+                        partial.push(lane);
+                        catalogRefused = true;
+                    }
+                    continue;
+                }
+            }
             const s = laneState(lanesHit, lane);
             if (lane === 'modelCatalogFile') {
                 if (s === 'complete') {
-                    const bit = own(reading, 'engineAcceptsCatalogDefault');
-                    const evidence = catalogDefaultEvidence(s, bit?.v);
+                    const evidence = catalogDefaultEvidence(s, catalogAdoptionOf(reading));
                     if (evidence !== undefined)
                         return { verdict: 'resolvable', why: 'catalog_default', evidence };
-                    if (bit !== undefined && bit.v === false) {
-                        partial.push(lane);
-                        catalogRefused = true;
-                    }
-                    else {
-                        catalogUnconfirmed = bit === undefined || bit.v === undefined ? 'not_reported' : 'unusable';
-                    }
+                    partial.push(lane);
+                    catalogRefused = true;
                     continue;
                 }
             }
@@ -88,8 +114,8 @@ function analyse(reading) {
             else if (s === 'unusable')
                 unusable.push(lane);
         }
-        if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0 || catalogUnconfirmed !== null) {
-            return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable, catalogUnconfirmed, catalogRefused };
+        if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0) {
+            return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable, catalogRefused };
         }
         return { verdict: 'not_resolvable', why: 'lanes', partial, catalogRefused };
     }
@@ -100,6 +126,26 @@ function analyse(reading) {
 export function modelIdentityResolvability(reading) {
     return analyse(reading).verdict;
 }
+export function modelIdentityCatalogDeviationOf(reading) {
+    try {
+        if (!isPlainObject(reading) || own(reading, 'engine')?.v !== 'local')
+            return undefined;
+        const lanesHit = own(reading, 'lanes')?.v;
+        if (!isPlainObject(lanesHit))
+            return undefined;
+        const derived = catalogFactsDerivedOf(reading);
+        if (derived === undefined)
+            return undefined;
+        const reported = laneState(lanesHit, 'modelCatalogFile');
+        if (reported === 'not_reported')
+            return undefined;
+        const withoutFacts = reported === 'complete' ? 'partial' : reported;
+        return withoutFacts === derived ? undefined : Object.freeze({ kind: 'catalog_lane_overridden_by_facts', reported, derived });
+    }
+    catch {
+        return undefined;
+    }
+}
 const LANE_LABEL_KEYS = Object.freeze({
     processEnv: 'model.identity.lane.processEnv',
     settingsEnv: 'model.identity.lane.settingsEnv',
@@ -152,9 +198,10 @@ export function modelIdentityDetail(reading) {
                 ? `${joinPhrases(others.map(laneLabel))} ${others.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name`
                 : '';
             if (a.catalogRefused) {
-                return (`no model name is configured for the local engine to start with — ${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name` +
-                    (partialClause !== '' ? `, and ${partialClause}` : '') +
-                    ', and the engine does not start without one');
+                const clause = msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) });
+                return partialClause !== ''
+                    ? renderMessage(msg('model.identity.catalogAdoption.notResolvableWithPartial', { clause, partial: partialClause }))
+                    : renderMessage(msg('model.identity.catalogAdoption.notResolvable', { clause }));
             }
             if (others.length > 0) {
                 return `no model name is configured for the local engine — ${partialClause}, and the engine does not start without one`;
@@ -173,14 +220,8 @@ export function modelIdentityDetail(reading) {
                     ...a.unreported.map((l) => `${laneLabel(l)} was not reported`),
                     ...a.unusable.map((l) => `${laneLabel(l)} gave no usable reading`),
                 ];
-                if (a.catalogUnconfirmed === 'not_reported') {
-                    parts.push(`${laneLabel('modelCatalogFile')} names a default model, but whether the local engine accepts a catalog default in place of a startup model name was not reported`);
-                }
-                else if (a.catalogUnconfirmed === 'unusable') {
-                    parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the report of whether the local engine accepts a catalog default in place of a startup model name gave no usable reading`);
-                }
-                else if (a.catalogRefused) {
-                    parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name`);
+                if (a.catalogRefused) {
+                    parts.push(renderMessage(msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) })));
                 }
                 return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;
             }
@@ -220,6 +261,6 @@ export function modelSetupNotice(decision) {
             return null;
     }
 }
-export function observedEngineAnswer(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedEngineAnswer(baseUrl = engineWireTargetBaseUrl()) {
     return engineCapsLandingOf(baseUrl).kind === 'not_landed' ? 'not_observed' : 'answered';
 }

package/dist/modsKernelIdentity.d.ts

@@ -0,0 +1,10 @@
+import type { ModEventRow } from '@sema-agent/mods-kernel';
+export interface ModsKernelSource {
+    readonly KERNEL_CONTRACT_VERSION: number;
+    readonly MOD_EVENT_TABLE: Readonly<Record<string, ModEventRow>>;
+}
+export interface ModsKernelIdentity {
+    readonly contractVersion: number;
+    readonly tableDigest: string;
+}
+export declare function modsKernelIdentity(kernel?: ModsKernelSource): ModsKernelIdentity;

package/dist/modsKernelIdentity.js

@@ -0,0 +1,103 @@
+import { KERNEL_CONTRACT_VERSION, MOD_EVENT_TABLE } from '@sema-agent/mods-kernel';
+const MAX_DEPTH = 16;
+const MAX_NODES = 100_000;
+function canonical(v, depth, budget) {
+    budget.nodes += 1;
+    if (budget.nodes > MAX_NODES)
+        throw new TypeError('modsKernelIdentity: the event table is larger than a data table is');
+    if (depth > MAX_DEPTH)
+        throw new TypeError('modsKernelIdentity: the event table nests deeper than a data table does');
+    if (v === null || typeof v === 'string' || typeof v === 'boolean')
+        return JSON.stringify(v);
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            throw new TypeError('modsKernelIdentity: the event table holds a number that is not finite');
+        return JSON.stringify(v);
+    }
+    if (Array.isArray(v)) {
+        const parts = [];
+        for (let i = 0; i < v.length; i++) {
+            if (!(i in v))
+                throw new TypeError('modsKernelIdentity: the event table holds an array with a hole');
+            parts.push(canonical(v[i], depth + 1, budget));
+        }
+        return `[${parts.join(',')}]`;
+    }
+    if (typeof v === 'object') {
+        const proto = Object.getPrototypeOf(v);
+        if (proto !== Object.prototype && proto !== null)
+            throw new TypeError('modsKernelIdentity: the event table holds an object that is not a plain record');
+        const o = v;
+        return `{${Object.keys(o)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonical(o[k], depth + 1, budget)}`)
+            .join(',')}}`;
+    }
+    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)
+            throw new TypeError('modsKernelIdentity: the source is not a kernel module');
+        const contractVersion = kernel.KERNEL_CONTRACT_VERSION;
+        const table = kernel.MOD_EVENT_TABLE;
+        if (typeof contractVersion !== 'number' || !Number.isFinite(contractVersion)) {
+            throw new TypeError('modsKernelIdentity: the source carries no readable contract number');
+        }
+        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 }))) };
+    }
+    catch (e) {
+        if (e instanceof TypeError)
+            throw e;
+        throw new TypeError('modsKernelIdentity: the source could not be read', { cause: e });
+    }
+}

package/dist/modsKernelTransit.d.ts

@@ -0,0 +1,8 @@
+export { KERNEL_CONTRACT_VERSION, MOD_TIERS, MOD_SEATS, MOD_EVENT_SIDES, MOD_FAILURE_ANSWERS, MOD_ABORT_POSTURES, NEXT_TO_TABLE, SEAT_TIER_TABLE, MOD_EVENT_TABLE, nextToRefusal, expandModPattern, isModEventName, stationOn, readOnSide, } from '@sema-agent/mods-kernel';
+export { DEFAULT_MOD_BUDGET_MS, CATCH_BUDGET_MS, RUNAWAY_AFTER_MS, POST_ABORT_GRACE_MS, MAX_TIMER_MS, resolveModBudgetMs, } from '@sema-agent/mods-kernel';
+export { MOD_FAILURE_CAUSES } from '@sema-agent/mods-kernel';
+export { ENGINE_ORIGIN, MODS_INVALID_CODE, MODS_REGISTRATION_REFUSED_CODE, MOD_TRACE_OUTCOMES } from '@sema-agent/mods-kernel';
+export { admitMods } from '@sema-agent/mods-kernel';
+export type { ModTier, ModRegistrationTier, ModSeat, ModEventSide, ModBusSide, ModFailureAnswer, ModAbortPosture, ModStation, ModEventRow, ModEventName, ModBudgetReading, ModFailureCause, ModEventPayload, ModAnswerCheck, ModAnswerer, ModMatcher, ModSkip, ModTraceOutcome, ModUses, ModOrigin, ModPluginFacts, ModDollarBase, ModTraceEntry, ModCaughtError, ModNext, ModHandler, ModHandlerOptions, On, ModRegistration, ModAdmissionRecord, ModSeats, ModFrame, ModBottomContext, ModMethodBottom, ModMethodSeat, ModMethodBottoms, ModDispatchOutcome, ModDispatchOptions, ModBus, ModMountedHandler, ModBusInput, } from '@sema-agent/mods-kernel';
+export { modsKernelIdentity } from './modsKernelIdentity.js';
+export type { ModsKernelIdentity, ModsKernelSource } from './modsKernelIdentity.js';

package/dist/modsKernelTransit.js

@@ -0,0 +1,6 @@
+export { KERNEL_CONTRACT_VERSION, MOD_TIERS, MOD_SEATS, MOD_EVENT_SIDES, MOD_FAILURE_ANSWERS, MOD_ABORT_POSTURES, NEXT_TO_TABLE, SEAT_TIER_TABLE, MOD_EVENT_TABLE, nextToRefusal, expandModPattern, isModEventName, stationOn, readOnSide, } from '@sema-agent/mods-kernel';
+export { DEFAULT_MOD_BUDGET_MS, CATCH_BUDGET_MS, RUNAWAY_AFTER_MS, POST_ABORT_GRACE_MS, MAX_TIMER_MS, resolveModBudgetMs, } from '@sema-agent/mods-kernel';
+export { MOD_FAILURE_CAUSES } from '@sema-agent/mods-kernel';
+export { ENGINE_ORIGIN, MODS_INVALID_CODE, MODS_REGISTRATION_REFUSED_CODE, MOD_TRACE_OUTCOMES } from '@sema-agent/mods-kernel';
+export { admitMods } from '@sema-agent/mods-kernel';
+export { modsKernelIdentity } from './modsKernelIdentity.js';

package/dist/notifications.d.ts

@@ -1,4 +1,5 @@
 import type { PlanReviewOutcomeMeta } from './hitl/planReviewWire.js';
+import type { SubmissionKind } from './request/submissionIdentity.js';
 export interface TaskNotificationFields {
     taskId: string;
     status: string;
@@ -15,17 +16,33 @@ export interface TaskNotificationFields {
     recentSteps?: string[];
     resumable?: boolean;
     externalSource?: string;
+    completionId?: string;
+    seq?: number;
+}
+export declare const CORE_TASK_NOTIFICATION_TAGS: readonly string[];
+export declare function renderTaskNotificationXml(raw: TaskNotificationFields): string;
+export declare function freezeTaskNotificationFields(n: TaskNotificationFields): Readonly<TaskNotificationFields>;
+export interface PendingNotificationCommand {
+    readonly value: string;
+    readonly mode: 'task-notification';
+    readonly _sema_task_notification?: Readonly<TaskNotificationFields>;
+}
+export interface TaskNotificationQueueCommand {
+    readonly value: string;
+    readonly mode: 'task-notification';
+    readonly _sema_task_notification: Readonly<TaskNotificationFields>;
 }
-export declare function renderTaskNotificationXml(n: TaskNotificationFields): string;
-export declare function deriveNotificationResidualLines(n: Record<string, unknown>): string[];
-export declare function normalizeTaskNotification(n: Record<string, unknown>): TaskNotificationFields | null;
+export declare function taskNotificationQueueCommand(n: TaskNotificationFields): TaskNotificationQueueCommand;
+export declare function taskNotificationOf(carrier: object | null | undefined): Readonly<TaskNotificationFields> | undefined;
+export declare function deriveNotificationResidualLines(raw: Record<string, unknown>): string[];
+export declare function normalizeTaskNotification(raw: Record<string, unknown>): TaskNotificationFields | null;
 export declare function taskNotificationDedupKey(n: {
     taskId: string;
     status: string;
     seq?: number | string;
     taskType?: string;
 }): string;
-export declare function taskNotificationDedupKeyFromWire(n: Record<string, unknown>): string;
+export declare function taskNotificationDedupKeyFromWire(raw: Record<string, unknown>): string;
 export interface TranscriptNotificationSeeds {
     renderedKeys: string[];
     notifiedKeys: string[];
@@ -38,16 +55,15 @@ export interface TaskNotificationXmlRead {
     readonly external: boolean;
 }
 export declare function readTaskNotificationXml(xml: string): TaskNotificationXmlRead | undefined;
+export declare const TASK_NOTIFICATION_TAG = "task-notification";
 export interface QueuedCommandLike {
     mode?: unknown;
     agentId?: unknown;
     value?: unknown;
+    _sema_task_notification?: {} | null;
 }
 export interface NotificationQueuePort {
-    enqueuePendingNotification(command: {
-        value: string;
-        mode: 'task-notification';
-    }): void;
+    enqueuePendingNotification(command: PendingNotificationCommand): void;
     removeByFilter(predicate: (cmd: QueuedCommandLike) => boolean): QueuedCommandLike[];
     enqueueMetaPrompt?(command: {
         value: string;
@@ -91,6 +107,7 @@ export declare function installWorkflowStatusProbe(probe: WorkflowStatusProbe):
 type BgTaskStatusProbe = (taskId: string) => Promise<{
     terminal: boolean;
     status: string;
+    completionId?: string;
 } | null>;
 export declare function outstandingBgTaskPrompt(taskId: string): string | undefined;
 export declare function installBgTaskStatusProbe(probe: BgTaskStatusProbe): void;
@@ -104,21 +121,22 @@ export interface EngineWorkflowCompletion {
     status: 'completed' | 'failed';
     summary: string;
 }
-export declare function enqueueBgChildNotification(n: {
+export declare function enqueueBgChildNotification(raw: {
     taskId: string;
     status: string;
     seq?: number;
     summary?: string;
+    completionId?: string;
 }): void;
-export declare function enqueueEngineWorkflowNotification(c: EngineWorkflowCompletion): void;
+export declare function enqueueEngineWorkflowNotification(raw: EngineWorkflowCompletion): void;
 export declare function _resetEngineTaskNotificationForTest(): void;
 export declare function _tickWatchOnceForTest(nowMs?: number): Promise<void>;
 export declare function _setWatcherTimingForTest(o: {
     probeTimeoutMs?: number;
     stuckTickResetMs?: number;
 } | null): void;
-export declare function isTaskNotificationObjective(objective: unknown): boolean;
-export declare function taskNotificationDeliverySupplement(objective: unknown): string | undefined;
+export declare function isTaskNotificationObjective(objective: unknown, kind?: SubmissionKind): boolean;
+export declare function taskNotificationDeliverySupplement(objective: unknown, kind?: SubmissionKind, notification?: Pick<TaskNotificationFields, 'status'>): string | undefined;
 export declare function splitApiErrorSupplement(text: string): {
     main: string;
     supplement?: string;