@sema-agent/client-core 0.112.0 → 0.113.0

package/dist/localConfig/modelPool.js

@@ -8,11 +8,11 @@ import { computeDeleteBlockers, computeDeleteWarnings, resolveEntryVision } from
 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 { ownDataField, ownSnapshotRecord, ownSnapshotRecordFaithful, putOwnKey, readOwnDataValue, sameJson } 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';
+import { MODEL_POOL_CHANNEL_SOURCES, MODEL_POOL_EDIT_KINDS, MODEL_POOL_MAX_BATCH, MODEL_POOL_READINGS } 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) {
@@ -30,19 +30,6 @@ function cloneDoc(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;
@@ -204,10 +191,16 @@ 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([]);
 }
+function shadowUnknownDisclosures() {
+    return Object.freeze([Object.freeze({ kind: 'shadow_unknown', layer: 'userSettings', detail: 'model' })]);
+}
+function shadowOf(settings, reading) {
+    return reading === 'unreadable' ? shadowUnknownDisclosures() : shadowDisclosuresOf(settings);
+}
 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'));
+    const disclosures = shadowOf(own(input, 'userSettings'), own(input, 'userSettingsReading'));
     try {
         const raw = own(input, 'modelsDoc');
         if (raw === null || raw === undefined)
@@ -659,7 +652,7 @@ function planUpdate(edit, modelsRaw, settingsRaw) {
         m['maxTokens'] = max;
     return okPlan(modelsRaw, doc, settingsRaw, settingsOrEmpty(settingsRaw), {});
 }
-function planSetDefault(name, modelsRaw, settingsRaw) {
+function planSetDefault(name, modelsRaw, settingsRaw, settingsReading) {
     if (typeof name !== 'string' || name === '')
         return refuse('invalid_request');
     const mread = modelsDocOf(modelsRaw);
@@ -673,7 +666,7 @@ function planSetDefault(name, modelsRaw, settingsRaw) {
     const roles = isRecord(doc['roles']) ? doc['roles'] : {};
     roles['default'] = { model: name };
     doc['roles'] = roles;
-    return okPlan(modelsRaw, doc, settingsRaw, settingsOrEmpty(settingsRaw), { disclosures: shadowDisclosuresOf(settingsRaw) });
+    return okPlan(modelsRaw, doc, settingsRaw, settingsOrEmpty(settingsRaw), { disclosures: shadowOf(settingsRaw, settingsReading) });
 }
 function planImportEnv(modelsRaw, settingsRaw, env) {
     const mread = modelsDocOf(modelsRaw);
@@ -869,7 +862,7 @@ function envOf(v) {
     }
     return out;
 }
-function planWith(edit, modelsDoc, settingsDoc, effectiveEnv, pins, declineDefault = false) {
+function planWith(edit, modelsDoc, settingsDoc, effectiveEnv, pins, declineDefault = false, settingsReading) {
     try {
         const kind = own(edit, 'kind');
         const env = envOf(effectiveEnv);
@@ -887,7 +880,7 @@ function planWith(edit, modelsDoc, settingsDoc, effectiveEnv, pins, declineDefau
             case 'remove':
                 return planRemove(own(edit, 'name'), modelsDoc, settingsDoc);
             case 'setDefault':
-                return planSetDefault(own(edit, 'name'), modelsDoc, settingsDoc);
+                return planSetDefault(own(edit, 'name'), modelsDoc, settingsDoc, settingsReading);
             case 'importEnvModels':
                 return planImportEnv(modelsDoc, settingsDoc, env);
             case 'bindTier':
@@ -937,7 +930,7 @@ export function modelPoolIntentOf(edit, effectiveEnv, probe) {
         const settings = docFrom(input.fresh.userSettings);
         if (models === 'unreadable' || (settings === 'unreadable' && needsSettings))
             return undefined;
-        return { models, settings: settings === 'unreadable' ? null : settings };
+        return { models, settings: settings === 'unreadable' ? null : settings, settingsReading: settings === 'unreadable' ? 'unreadable' : undefined };
     };
     const modelsStep = (role, withPins) => ({
         doc: 'models',
@@ -952,7 +945,7 @@ export function modelPoolIntentOf(edit, effectiveEnv, probe) {
             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));
+            const p = record(planWith(edit, r.models, r.settings, effectiveEnv, pins, false, r.settingsReading));
             if (!p.ok)
                 return refuseStep(p);
             const carry = { released: [...p.releasedKeySlots] };
@@ -1327,11 +1320,91 @@ function providersOf() {
         });
     }));
 }
+function envHasDroppedKeys(given, snap) {
+    try {
+        if (typeof given !== 'object' || given === null)
+            return true;
+        for (const k of Reflect.ownKeys(given)) {
+            if (typeof k !== 'string' || Object.hasOwn(snap, k))
+                continue;
+            const d = Object.getOwnPropertyDescriptor(given, k);
+            if (d === undefined || d.enumerable !== true || !Object.hasOwn(d, 'value') || d.value !== undefined)
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function viewEnvOf(readings) {
+    let given;
+    try {
+        given = typeof readings === 'object' && readings !== null ? ownDataField(readings, 'effectiveEnv') : undefined;
+    }
+    catch {
+        return { reading: 'unreadable', env: {} };
+    }
+    if (given === undefined)
+        return { reading: 'absent', env: {} };
+    const snap = ownSnapshotRecordFaithful(given);
+    if (snap === undefined || envHasDroppedKeys(given, snap))
+        return { reading: 'unreadable', env: {} };
+    const env = {};
+    for (const k of Object.keys(snap)) {
+        const val = snap[k];
+        if (typeof val !== 'string')
+            return { reading: 'unreadable', env: {} };
+        putOwnKey(env, k, val);
+    }
+    return { reading: 'read', env };
+}
+function viewSettingsOf(readings) {
+    try {
+        const sr = typeof readings === 'object' && readings !== null ? ownDataField(readings, 'userSettings') : undefined;
+        if (sr === undefined)
+            return { reading: 'absent', raw: null };
+        if (typeof sr !== 'object' || sr === null)
+            return { reading: 'unreadable', raw: null };
+        const status = ownDataField(sr, 'status');
+        if (status === 'absent')
+            return { reading: 'absent', raw: null };
+        if (status !== 'loaded')
+            return { reading: 'unreadable', raw: null };
+        const doc = ownDataField(sr, 'doc');
+        if (typeof doc !== 'object' || doc === null || Array.isArray(doc))
+            return { reading: 'unreadable', raw: null };
+        const checked = settingsDocOf(doc);
+        if (!checked.ok)
+            return { reading: 'unreadable', raw: null };
+        return { reading: 'read', raw: checked.doc };
+    }
+    catch {
+        return { reading: 'unreadable', raw: null };
+    }
+}
+export function modelPoolEnvReadingOf(view) {
+    if (typeof view !== 'object' || view === null)
+        return 'unreadable';
+    try {
+        const d = Object.getOwnPropertyDescriptor(view, 'effectiveEnv');
+        if (d === undefined)
+            return 'not_reported';
+        if (!Object.hasOwn(d, 'value'))
+            return 'unreadable';
+        const word = d.value;
+        if (word === undefined)
+            return 'not_reported';
+        return MODEL_POOL_READINGS.find((w) => w === word) ?? 'unreadable';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
 export function modelPoolViewOf(readings) {
-    const env = envOf(own(readings, 'effectiveEnv'));
+    const { reading: envReading, env } = viewEnvOf(readings);
     const mr = own(readings, 'models');
-    const sr = own(readings, 'userSettings');
-    const settingsRaw = own(sr, 'status') === 'loaded' ? own(sr, 'doc') : null;
+    const { reading: settingsReading, raw: settingsRaw } = viewSettingsOf(readings);
     const settings = settingsDocOf(settingsRaw);
     const sdoc = settings.ok ? settings.doc : {};
     const legacyTierSettings = sdoc['semaTierGroups'] !== undefined || sdoc['semaRosters'] !== undefined;
@@ -1344,10 +1417,12 @@ export function modelPoolViewOf(readings) {
         entries: Object.freeze([]),
         roles: Object.freeze([]),
         tierGroups: Object.freeze([]),
-        defaultModel: catalog === 'absent' ? effectiveDefaultModelOf({ modelsDoc: null, userSettings: settingsRaw }) : unknownDefault(shadowDisclosuresOf(settingsRaw)),
+        defaultModel: catalog === 'absent' ? effectiveDefaultModelOf({ modelsDoc: null, userSettings: settingsRaw, userSettingsReading: settingsReading }) : unknownDefault(shadowOf(settingsRaw, settingsReading)),
         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() !== '')),
+        effectiveEnv: envReading,
+        userSettings: settingsReading,
         providers: providersOf(),
     });
     if (status === 'absent')
@@ -1363,7 +1438,7 @@ export function modelPoolViewOf(readings) {
     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 def = effectiveDefaultModelOf({ modelsDoc: raw, userSettings: settingsRaw, userSettingsReading: settingsReading });
     const blockDoc = withDefaultFolded(doc);
     const groups = tierGroupsOf(raw).filter((g) => typeof g['name'] === 'string');
     const active = typeof raw['activeTierGroup'] === 'string' ? raw['activeTierGroup'] : undefined;
@@ -1452,6 +1527,8 @@ export function modelPoolViewOf(readings) {
         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() !== '')),
+        effectiveEnv: envReading,
+        userSettings: settingsReading,
         providers: providersOf(),
     });
 }

package/dist/localConfig/modelPoolWords.d.ts

@@ -11,3 +11,5 @@ export declare const MODEL_POOL_DEFAULT_KEEP_REASONS: readonly ["has_default", "
 export type ModelPoolDefaultKeepReason = (typeof MODEL_POOL_DEFAULT_KEEP_REASONS)[number];
 export declare const MODEL_POOL_COMPLETENESS: readonly ["complete", "catalog_incomplete"];
 export type ModelPoolCompleteness = (typeof MODEL_POOL_COMPLETENESS)[number];
+export declare const MODEL_POOL_READINGS: readonly ["read", "absent", "unreadable"];
+export type ModelPoolViewReading = (typeof MODEL_POOL_READINGS)[number];

package/dist/localConfig/modelPoolWords.js

@@ -18,3 +18,4 @@ export const MODEL_POOL_MAX_BATCH = 64;
 export const MODEL_POOL_PROBE_STATES = Object.freeze(['verified', 'unverified', 'unprobed']);
 export const MODEL_POOL_DEFAULT_KEEP_REASONS = Object.freeze(['has_default', 'existing_unknown', 'declined', 'nothing_added', 'none_verified']);
 export const MODEL_POOL_COMPLETENESS = Object.freeze(['complete', 'catalog_incomplete']);
+export const MODEL_POOL_READINGS = Object.freeze(['read', 'absent', 'unreadable']);

package/dist/localConfig/settingsWrite.js

@@ -2,7 +2,7 @@ import { SETTINGS_UNIT_PLACES, SETTINGS_WORKSPACE_TRUST_STATES } from '../genera
 import { SETTINGS_IS_RESERVED_MEMBER_NAME } from '../generated/settingsSchemaFns.js';
 import { layerAdmissionWord } from '../settingsLayerAdmission.js';
 import { KEY_SLOT_PREFIX } from '../model/onboardJudgement.js';
-import { ownSnapshotRecord, readOwnDataValue } from '../ownKey.js';
+import { ownSnapshotRecord, readOwnDataValue, sameJson } from '../ownKey.js';
 import { SKILL_OVERRIDE_STATES } from '../skillOverrideChain.js';
 const unitKey = (unit) => SETTINGS_UNIT_PLACES[unit].path;
 const SKILL_OVERRIDE_WORDS = SKILL_OVERRIDE_STATES;
@@ -93,19 +93,6 @@ function listWith(current, name, present) {
         return list.filter((x) => x !== name);
     return list.includes(name) ? list : [...list, name];
 }
-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]));
-}
 export function settingsWritePlan(input) {
     try {
         if (!isPlainRecord(input))

package/dist/localConfig/skills.js

@@ -1,8 +1,8 @@
 import { SETTINGS_IS_RESERVED_MEMBER_NAME } from '../generated/settingsSchemaFns.js';
 import { readOwnDataValue, appendOwnElement } from '../ownKey.js';
-import { SKILL_OVERRIDE_STATES, effectiveOfShaped, lockOfShaped, lowerTierOf, ownValueIn, secondaryNamesOf, bareNameOf, shapeSkillLayers, shapeSkillSubject, stateAt, withLayerDoc, } from '../skillOverrideChain.js';
+import { LIST_BUDGET, SKILL_OVERRIDE_STATES, effectiveOfShaped, lockOfShaped, lowerTierOf, ownValueIn, secondaryNamesOf, bareNameOf, shapeSkillLayers, shapeSkillSubject, stateAt, withLayerDoc, } from '../skillOverrideChain.js';
 import { settingsWritePlan } from './settingsWrite.js';
-import { isDotSegment } from '../sessionIdSegment.js';
+import { pathShapeOf, PATH_LENGTH_LIMIT } from '../pathShape.js';
 import { slotReadOf } from '../wireFailureShape.js';
 import { SKILL_ROOT_LAYERS, SKILL_ROOT_KINDS, SKILL_OVERRIDE_SCOPES } from './skillsWords.js';
 function own(v, key) {
@@ -16,7 +16,6 @@ function own(v, key) {
     }
 }
 const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-const LIST_BUDGET = 4096;
 function listOf(v) {
     if (!Array.isArray(v))
         return [];
@@ -30,24 +29,18 @@ function listOf(v) {
 }
 const TRUST_LAYERS = ['project', 'additional'];
 function pathFormOf(raw) {
-    if (typeof raw !== 'string' || raw === '' || raw.length > 4096 || raw.includes('\u0000'))
+    if (typeof raw !== 'string' || raw.length > PATH_LENGTH_LIMIT)
         return undefined;
-    const sep = raw.includes('\\') && !raw.includes('/') ? '\\' : '/';
-    let floor;
-    if (raw.startsWith('/'))
-        floor = '/';
-    else if (/^[A-Za-z]:[\\/]/.test(raw))
-        floor = raw.slice(0, 3);
-    else if (/^\\\\[^\\/]+[\\/][^\\/]+/.test(raw))
-        floor = raw.match(/^\\\\[^\\/]+[\\/][^\\/]+/)[0];
-    else
+    const shape = pathShapeOf(raw);
+    if (shape === undefined || shape.kind === 'relative' || shape.hasDotSegment || shape.hasEmptySegment)
+        return undefined;
+    if (shape.kind === 'unc' && shape.names.length > 0)
         return undefined;
+    const sep = raw.includes('\\') && !raw.includes('/') ? '\\' : '/';
+    const floor = shape.root;
     let path = raw;
     while (path.length > floor.length && (path.endsWith('/') || path.endsWith('\\')))
         path = path.slice(0, -1);
-    const rest = path.slice(floor.length);
-    if (rest !== '' && rest.split(/[\\/]/).some((seg) => seg === '' || isDotSegment(seg)))
-        return undefined;
     return { sep, path, floor };
 }
 const joinPath = (f, ...segs) => (f.path === f.floor && /[\\/]$/.test(f.floor) ? f.path + segs.join(f.sep) : [f.path, ...segs].join(f.sep));

package/dist/localEngineSpawn.d.ts

@@ -13,6 +13,9 @@ export type LocalEngineSpawnValue = {
 } | {
     readonly kind: 'derived';
     readonly from: LocalEngineSpawnDerived;
+} | {
+    readonly kind: 'gated';
+    readonly value: string;
 };
 export interface LocalEngineSpawnEnvRow {
     readonly key: string;
@@ -25,6 +28,28 @@ export declare const LOCAL_ENGINE_SPAWN_SHAPE: Readonly<{
     readonly detachedSession: true;
     readonly stdio: "engine-log-file";
 }>;
+export declare const LOCAL_ENGINE_SEED_REFUSALS: readonly ["policy-unreadable", "bind-not-acknowledged"];
+export type LocalEngineSeedRefusal = (typeof LOCAL_ENGINE_SEED_REFUSALS)[number];
+export type LocalEngineBindRefusal = Extract<LocalEngineSeedRefusal, 'bind-not-acknowledged'>;
+export declare const LOCAL_ENGINE_BIND_DISCLOSURES: readonly ["bind-acknowledged"];
+export type LocalEngineBindDisclosure = (typeof LOCAL_ENGINE_BIND_DISCLOSURES)[number];
+export declare function localEngineSeedRefusalCodeOf(refusal: string): string | undefined;
+export interface LocalEngineBindGateInput {
+    readonly requested?: string | undefined;
+    readonly acknowledged?: boolean | undefined;
+}
+export interface LocalEngineBindPass {
+    readonly kind: 'pass';
+    readonly handed: string | undefined;
+    readonly disclose: boolean;
+}
+export interface LocalEngineBindRefuse {
+    readonly kind: 'refuse';
+    readonly reason: LocalEngineBindRefusal;
+}
+export type LocalEngineBindGate = LocalEngineBindPass | LocalEngineBindRefuse;
+export declare function localEngineBindGateOf(input: LocalEngineBindGateInput): LocalEngineBindGate;
+export declare function localEngineBindSentence(gate: LocalEngineBindGate, switchKey: string, lang?: UiLanguage): string | undefined;
 export declare function localEngineOperatorSingleUserOf(inherited: unknown): 'true' | undefined;
 export interface LocalEngineBudgets {
     readonly storeLockWaitMs: number;
@@ -41,6 +66,7 @@ export interface LocalEngineSpawnEnvInput {
     readonly inherited: unknown;
     readonly paths: LocalEngineSpawnPaths;
     readonly hostBits: unknown;
+    readonly bind?: LocalEngineBindGate | undefined;
 }
 export interface LocalEngineSpawnApplied {
     readonly key: string;
@@ -72,6 +98,7 @@ export interface LocalEngineSeedInput {
     readonly layers: LocalEngineSettingsLayers;
     readonly topLevel: unknown;
     readonly platform: 'posix' | 'win32';
+    readonly bindAcknowledged?: boolean | undefined;
 }
 export interface LocalEngineSeedFrom {
     readonly key: string;
@@ -85,7 +112,8 @@ export interface LocalEngineSeed {
     readonly env: Readonly<Record<string, string>>;
     readonly from: readonly LocalEngineSeedFrom[];
     readonly dropped: readonly LocalEngineSeedDropped[];
-    readonly refuse?: 'policy-unreadable';
+    readonly bind: LocalEngineBindGate;
+    readonly refuse?: LocalEngineSeedRefusal;
 }
 export declare function localEngineSeedEnv(input: LocalEngineSeedInput): LocalEngineSeed;
 export type LocalEnginePrincipal = {

package/dist/localEngineSpawn.js

@@ -67,7 +67,9 @@ function freezeRecord(rows) {
         Object.defineProperty(out, k, { value: v, enumerable: true, writable: true, configurable: true });
     return Object.freeze(out);
 }
+const BIND_DEFAULT = '127.0.0.1';
 const lit = (value) => Object.freeze({ kind: 'literal', value });
+const gated = (value) => Object.freeze({ kind: 'gated', value });
 const del = Object.freeze({ kind: 'delete' });
 const slot = (s) => Object.freeze({ kind: 'path', slot: s });
 const derived = (from) => Object.freeze({ kind: 'derived', from });
@@ -78,7 +80,8 @@ export const LOCAL_ENGINE_SPAWN_ENV = Object.freeze([
     row('ENGINE_AUTO_EXIT', lit('true'), true),
     row('SEMA_PARENT_PID', del, false),
     row('SEMA_ENGINE_PARENT_PID', del, false),
-    row('BIND_HOST', lit('127.0.0.1'), true),
+    row('BIND_HOST', gated(BIND_DEFAULT), false),
+    row('BIND_HOST_INSECURE_SELF_SPAWN', del, false),
     row('DB_BACKEND', lit('local'), false),
     row('CONFIG_PROVIDER', lit('local'), false),
     row('REMOTE_EXEC', lit('host'), true),
@@ -94,6 +97,52 @@ export const LOCAL_ENGINE_SPAWN_ENV = Object.freeze([
 ]);
 export const LOCAL_ENGINE_HOST_BITS = Object.freeze(['PORT', 'SERVICE_AUTH_TOKENS', 'ELECTRON_RUN_AS_NODE', 'NODE_ENV', 'HOST_SHELL_PATH']);
 export const LOCAL_ENGINE_SPAWN_SHAPE = Object.freeze({ detachedSession: true, stdio: 'engine-log-file' });
+export const LOCAL_ENGINE_SEED_REFUSALS = Object.freeze(['policy-unreadable', 'bind-not-acknowledged']);
+export const LOCAL_ENGINE_BIND_DISCLOSURES = Object.freeze(['bind-acknowledged']);
+export function localEngineSeedRefusalCodeOf(refusal) {
+    return LOCAL_ENGINE_SEED_REFUSALS.includes(refusal) ? refusal.replace(/-/g, '_') : undefined;
+}
+export function localEngineBindGateOf(input) {
+    const raw = own(input, 'requested');
+    const requested = typeof raw === 'string' ? raw.trim() : '';
+    if (requested === '' || requested === BIND_DEFAULT)
+        return Object.freeze({ kind: 'pass', handed: undefined, disclose: false });
+    if (own(input, 'acknowledged') === true)
+        return Object.freeze({ kind: 'pass', handed: requested, disclose: true });
+    return Object.freeze({ kind: 'refuse', reason: 'bind-not-acknowledged' });
+}
+function bindSentenceKeyOf(word) {
+    switch (word) {
+        case 'bind-not-acknowledged':
+            return 'localEngine.bindNotAcknowledged';
+        case 'bind-acknowledged':
+            return 'localEngine.bindAcknowledged';
+    }
+}
+export function localEngineBindSentence(gate, switchKey, lang) {
+    try {
+        const kind = own(gate, 'kind');
+        if (kind === 'refuse') {
+            if (own(gate, 'reason') !== 'bind-not-acknowledged')
+                return undefined;
+            if (typeof switchKey !== 'string' || !/^[^\s\p{C}]{1,128}$/u.test(switchKey))
+                return undefined;
+            return renderMessage(msg(bindSentenceKeyOf('bind-not-acknowledged'), { switchKey }), lang);
+        }
+        if (kind === 'pass' && own(gate, 'disclose') === true)
+            return renderMessage(msg(bindSentenceKeyOf(LOCAL_ENGINE_BIND_DISCLOSURES[0])), lang);
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function bindHandedOf(verdict) {
+    if (own(verdict, 'kind') !== 'pass')
+        return undefined;
+    const handed = own(verdict, 'handed');
+    return typeof handed === 'string' && handed !== '' && handed === handed.trim() ? handed : undefined;
+}
 const BOOL_TRUE = new Set(['true', '1', 'yes', 'on']);
 const OPERATOR_DECLARATION_KEYS = Object.freeze({ requirePrincipal: 'REQUIRE_PRINCIPAL', principals: 'OPERATOR_PRINCIPALS', singleUser: 'OPERATOR_SINGLE_USER' });
 export function localEngineOperatorSingleUserOf(inherited) {
@@ -152,6 +201,7 @@ export function localEngineSpawnEnv(input) {
         for (const [k, v] of envEntriesOf(own(input, 'inherited')) ?? [])
             env.set(k, v);
         const paths = own(input, 'paths');
+        const bindHanded = bindHandedOf(own(input, 'bind'));
         for (const r of LOCAL_ENGINE_SPAWN_ENV) {
             const inheritedValue = env.get(r.key);
             if (r.value.kind === 'delete') {
@@ -169,6 +219,11 @@ export function localEngineSpawnEnv(input) {
             let from = 'table';
             if (r.value.kind === 'literal')
                 value = r.value.value;
+            else if (r.value.kind === 'gated') {
+                value = bindHanded ?? r.value.value;
+                if (bindHanded !== undefined)
+                    from = 'user';
+            }
             else if (r.value.kind === 'path') {
                 const p = own(paths, r.value.slot);
                 value = typeof p === 'string' && p !== '' ? p : undefined;
@@ -311,11 +366,17 @@ export function localEngineSeedEnv(input) {
                 dropped.push(Object.freeze({ key: 'WORKFLOW_SIZE_GUIDELINE', why: 'top-level-invalid' }));
         }
     }
+    const bindKey = canon('BIND_HOST');
+    const bind = localEngineBindGateOf({ requested: merged.get(bindKey)?.value, acknowledged: own(input, 'bindAcknowledged') === true });
+    merged.delete(bindKey);
+    if (refuse === undefined && bind.kind === 'refuse')
+        refuse = bind.reason;
     const rows = [...merged.values()];
     return Object.freeze({
         env: freezeRecord(rows.map((r) => [r.key, r.value])),
         from: Object.freeze(rows.map((r) => Object.freeze({ key: r.key, source: r.source }))),
         dropped: Object.freeze(dropped),
+        bind,
         ...(refuse !== undefined ? { refuse } : {}),
     });
 }

package/dist/mcpLiveness.d.ts

@@ -29,7 +29,7 @@ export interface McpEngineLegHealth {
 }
 export declare function mcpLivenessRollupOf(rows: readonly McpLivenessBearingRow[] | undefined): McpEngineLegHealth;
 export declare function mcpEngineLegHealthDetail(health: McpEngineLegHealth | undefined): string;
-export declare const MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "host_refused", "unknown"];
+export declare const MCP_FAILURE_KINDS: readonly ["connect_refused", "connection_failed", "connection_closed", "unauthorized", "http_status", "not_mcp_response", "spawn_failed", "timeout", "protocol", "invalid_config", "credential_unavailable", "host_refused", "revoked", "unknown"];
 export declare const MCP_AUTHORIZATION_REASONS: readonly ["rejected", "scope", "none"];
 export declare const MCP_FAILURE_UNAUTHORIZED: Extract<(typeof CORE_MCP_FAILURE_KINDS)[number], 'unauthorized'>;
 export interface McpAuthorizationView {

package/dist/mcpProbeWire.js

@@ -1,6 +1,6 @@
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { wireFailureShapeOf } from './wireFailureShape.js';
-import { LIMIT_RATE_EXCEEDED } from './engineErrorCodes.js';
+import { LIMIT_RATE_EXCEEDED, ROUTE_NOT_FOUND } from './engineErrorCodes.js';
 import { mcpProbeAvailable } from './mcpProbeCapability.js';
 import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
@@ -39,7 +39,7 @@ export function classifyMcpProbeFailure(e) {
     if (errorCode === undefined || errorCode === '')
         return unknownBy('no_verdict', message, retryAfterSec);
     switch (errorCode) {
-        case 'not_found.route':
+        case ROUTE_NOT_FOUND:
             return refusedBy('face_absent', message);
         case 'capability.mcp_injection_required':
             return refusedBy('injection_not_honored', message);

package/dist/mcpReconnect.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { STEERING_NOT_RUNNING } from './engineErrorCodes.js';
+import { ROUTE_NOT_FOUND, STEERING_NOT_RUNNING } from './engineErrorCodes.js';
 import { ownDataField } from './ownKey.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { inSlotReadOf, inValueOf, slotReadOf } from './wireFailureShape.js';
@@ -147,7 +147,7 @@ export function classifyMcpReconnectFailure(e) {
         return { kind: 'unsupported', reason: 'capability' };
     if (typeof code === 'string' && code.startsWith('feature.'))
         return { kind: 'unsupported', reason: 'feature' };
-    if (code === 'not_found.route')
+    if (code === ROUTE_NOT_FOUND)
         return { kind: 'unsupported', reason: 'route' };
     if (code === 'not_found.session')
         return { kind: 'not_found' };

package/dist/model/catalogLoader.js

@@ -1,4 +1,6 @@
 import { hostEnv } from '../hostEnv.js';
+import { sha256BytesHex } from '../sha256Bytes.js';
+import { utf8Encode } from '../uuidV5.js';
 import { resolveModelCatalog, } from './catalog.js';
 export const DEFAULT_CATALOG_SOURCES = Object.freeze([
     'https://raw.githubusercontent.com/sema-agent/sema-model-catalog/main/dist/catalog.json',
@@ -61,18 +63,6 @@ export function catalogShaUrlFor(catalogUrl) {
 export function catalogCachePath(configHome) {
     return `${configHome.replace(/\/+$/, '')}/${CATALOG_CACHE_RELATIVE_PATH}`;
 }
-async function sha256Hex(text) {
-    const g = globalThis;
-    const subtle = g.crypto?.subtle;
-    const Enc = g.TextEncoder;
-    if (subtle === undefined || Enc === undefined)
-        return null;
-    const digest = await subtle.digest('SHA-256', new Enc().encode(text));
-    let out = '';
-    for (const b of new Uint8Array(digest))
-        out += b.toString(16).padStart(2, '0');
-    return out;
-}
 function parseShaFile(text) {
     const m = /\b([0-9a-fA-F]{64})\b/.exec(text);
     return m?.[1] === undefined ? null : m[1].toLowerCase();
@@ -202,14 +192,10 @@ export async function loadCatalogWithSources(opts) {
         let shaChecked = false;
         if (shaGot.outcome === 'ok' && shaGot.text !== undefined) {
             const expected = parseShaFile(shaGot.text);
-            const actual = await sha256Hex(got.text);
             if (expected === null) {
                 warnings.push(`catalog sha256 sidecar for ${finalUrl} is not a hex digest — payload accepted without the checksum`);
             }
-            else if (actual === null) {
-                warnings.push('no WebCrypto SHA-256 in this host — catalog payload accepted without the checksum');
-            }
-            else if (expected !== actual) {
+            else if (expected !== sha256BytesHex(utf8Encode(got.text))) {
                 attempts.push({ url: src, outcome: 'sha-mismatch', detail: 'catalog.sha256 does not match the payload digest' });
                 continue;
             }

package/dist/model/onboardJudgement.d.ts

@@ -39,6 +39,14 @@ export interface OnboardProbeResponse {
     text(): Promise<string>;
 }
 export type OnboardProbeFetch = (url: string, init: OnboardProbeRequestInit) => Promise<OnboardProbeResponse>;
+export declare const ONBOARD_PROBE_BUDGETS: Readonly<{
+    firstTokenMs: 15000;
+    catalogMs: Readonly<{
+        'anthropic-messages': 8000;
+        'openai-completions': 10000;
+    }>;
+    discoveryMs: 10000;
+}>;
 export interface OnboardProbeDeps {
     readonly fetchImpl?: OnboardProbeFetch | undefined;
     readonly timeoutMs?: number | undefined;

package/dist/model/onboardJudgement.js

@@ -117,6 +117,11 @@ export function onboardBaseUrlProblem(url, lang) {
         return say('onboard.baseUrl.encoding');
     return undefined;
 }
+export const ONBOARD_PROBE_BUDGETS = Object.freeze({
+    firstTokenMs: 15_000,
+    catalogMs: Object.freeze({ 'anthropic-messages': 8_000, 'openai-completions': 10_000 }),
+    discoveryMs: 10_000,
+});
 function keyHeaders(api, key, auth) {
     const h = {};
     if (key !== undefined && key !== '') {
@@ -172,7 +177,7 @@ export async function probeModelEndpoint(target, deps) {
         return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
     };
     const timeoutMs = num('timeoutMs');
-    const deadlineMs = num('firstTokenMs') ?? timeoutMs ?? 15_000;
+    const deadlineMs = num('firstTokenMs') ?? timeoutMs ?? ONBOARD_PROBE_BUDGETS.firstTokenMs;
     const root = baseUrl.trim();
     try {
         if (joinRequestUrl(root, 'models') === undefined)
@@ -199,7 +204,7 @@ export async function probeModelEndpoint(target, deps) {
         ...(modelId !== undefined ? { modelId } : {}),
         fetch: fetchWithKey,
         firstTokenBudgetMs: deadlineMs,
-        catalogBudgetMs: timeoutMs ?? (api === 'anthropic-messages' ? 8000 : 10_000),
+        catalogBudgetMs: timeoutMs ?? ONBOARD_PROBE_BUDGETS.catalogMs[api],
         requestUrl: (path) => joinRequestUrl(root, path),
         redact: (text) => redact(text, redactKey),
     });
@@ -233,7 +238,7 @@ export async function discoverEndpointModels(target, deps) {
     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 budget = typeof t === 'number' && Number.isFinite(t) && t > 0 ? t : ONBOARD_PROBE_BUDGETS.discoveryMs;
     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 });