@sema-agent/client-core 0.100.0 → 0.101.0

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,10 +23,10 @@ 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;
@@ -35,6 +36,24 @@ 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))
@@ -51,34 +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: null };
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogRefused: false };
         }
         const partial = [];
         const unreadable = [];
         const unreported = [];
         const unusable = [];
-        let catalogRefused = null;
-        let catalogUnconfirmed = null;
+        let catalogRefused = false;
         for (const lane of order) {
-            const s = laneState(lanesHit, lane);
             if (lane === 'modelCatalogFile') {
-                if (s === 'complete') {
-                    if (catalogAdoptionOf(reading) === 'refused') {
+                const factsDerived = catalogFactsDerivedOf(reading);
+                if (factsDerived !== undefined) {
+                    if (factsDerived === 'partial') {
                         partial.push(lane);
-                        catalogRefused = 'adoption';
-                        continue;
+                        catalogRefused = true;
                     }
-                    const bit = own(reading, 'engineAcceptsCatalogDefault');
-                    const evidence = catalogDefaultEvidence(s, bit?.v);
+                    continue;
+                }
+            }
+            const s = laneState(lanesHit, lane);
+            if (lane === 'modelCatalogFile') {
+                if (s === 'complete') {
+                    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 = 'engine';
-                    }
-                    else {
-                        catalogUnconfirmed = bit === undefined || bit.v === undefined ? 'not_reported' : 'unusable';
-                    }
+                    partial.push(lane);
+                    catalogRefused = true;
                     continue;
                 }
             }
@@ -97,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 };
     }
@@ -109,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',
@@ -160,17 +197,12 @@ export function modelIdentityDetail(reading) {
             const partialClause = others.length > 0
                 ? `${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 === 'adoption') {
+            if (a.catalogRefused) {
                 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 (a.catalogRefused === 'engine') {
-                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');
-            }
             if (others.length > 0) {
                 return `no model name is configured for the local engine — ${partialClause}, and the engine does not start without one`;
             }
@@ -188,18 +220,9 @@ 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 === 'adoption') {
+                if (a.catalogRefused) {
                     parts.push(renderMessage(msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) })));
                 }
-                else if (a.catalogRefused === 'engine') {
-                    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`);
-                }
                 return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;
             }
             return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";
@@ -238,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;