@sema-agent/client-core 0.109.0 → 0.110.0

package/dist/hostTurnSettings.d.ts

@@ -1,22 +1,22 @@
-import type { TaskRequest } from '@sema-agent/sdk';
+import type { SemaSettings, TaskRequest } from '@sema-agent/sdk';
 import type { WireHooksConfig } from './finalVerifyWire.js';
 import type { memoryOffDeclared as MemoryOffDeclared } from './request/taskRequest.js';
 import type { EnvLike } from './hostEnv.js';
 import { type SettingsDocument } from './host.js';
-import type { HooksWirePlan, HooksWirePlanOptions } from './pluginHooksWire.js';
+import { type HooksWirePlan, type HooksWirePlanOptions } from './pluginHooksWire.js';
 import { type HostSettingsLayer, type HostSettingsSession, type HostSettingsSource } from './hostSettingsSource.js';
 import { type SubmissionIdentity } from './request/submissionIdentity.js';
 import { type WebSearchApiKeyFor } from './webSearchWireCaps.js';
 import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
 import { type PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
-export declare const HOST_SUPPLIED_KEYS: readonly ["settings.hooks", "settings.resolved", "settings.webSearch", "settings.outputStyle", "memory", "fileHistory"];
+export declare const HOST_SUPPLIED_KEYS: readonly ["settings.hooks", "settings.resolved", "settings.webSearch", "settings.outputStyle", "memory", "fileHistory", "settings.env"];
 export type HostSuppliedKey = (typeof HOST_SUPPLIED_KEYS)[number];
 export declare const HOST_SETTING_CAUSES: readonly ["carried", "entries_dropped", "source_rejected", "projection_failed", "source_unreadable", "empty", "no_source", "host_port_missing", "value_malformed", "held_previous", "policy_withheld"];
 export type HostSettingCause = (typeof HOST_SETTING_CAUSES)[number];
 export declare const HOST_SETTING_DISPOSITIONS: readonly ["carry", "carry_partial", "withhold_notice", "withhold_by_policy", "hold_for_consent", "refuse_turn", "unwired", "nothing_to_carry"];
 export type HostSettingDisposition = (typeof HOST_SETTING_DISPOSITIONS)[number];
 export type HostSettingPlane = 'turn' | 'session' | 'diagnostic';
-export type HostSettingNoticeId = 'HS-UNWIRED' | 'HS-MANAGED-REJECTED' | 'HS-PROJECTION' | 'HS-SOURCE-UNREADABLE' | 'HS-WEBSEARCH-MALFORMED' | 'HS-SWITCH-MALFORMED' | 'HS-FILEHISTORY-UNJUDGED' | 'HS-FILEHISTORY-RESTORE' | 'HS-MANAGED-UNREADABLE' | 'HS-LAYER-NOT-LOADED' | 'HS-HELD-PREVIOUS' | 'HS-STYLE-MISSING' | 'HS-STYLE-SAFE' | 'HS-LAYER-PARTS-UNREAD';
+export type HostSettingNoticeId = 'HS-UNWIRED' | 'HS-MANAGED-REJECTED' | 'HS-PROJECTION' | 'HS-SOURCE-UNREADABLE' | 'HS-WEBSEARCH-MALFORMED' | 'HS-SWITCH-MALFORMED' | 'HS-FILEHISTORY-UNJUDGED' | 'HS-FILEHISTORY-RESTORE' | 'HS-MANAGED-UNREADABLE' | 'HS-LAYER-NOT-LOADED' | 'HS-HELD-PREVIOUS' | 'HS-STYLE-MISSING' | 'HS-STYLE-SAFE' | 'HS-LAYER-PARTS-UNREAD' | 'HS-STYLE-OVERSIZE' | 'HS-STYLE-UNREADABLE';
 export interface HostSettingRow {
     readonly key: HostSuppliedKey;
     readonly cause: HostSettingCause;
@@ -61,6 +61,9 @@ export interface HostTurnSettingsSources {
         readonly reading: FileHistoryCaptureReading;
         readonly captureOff: boolean;
     } | 'none';
+    readonly env: {
+        readonly env: EnvLike;
+    } | 'none';
 }
 export interface HostWebSearchSource {
     readonly env: EnvLike;
@@ -83,6 +86,7 @@ export interface HostSettingsCarried {
     readonly outputStyle?: string;
     readonly memory?: TaskRequest['memory'];
     readonly fileHistory?: TaskRequest['fileHistory'];
+    readonly env?: NonNullable<SemaSettings['env']>;
 }
 export interface HostOutputStyleFacts {
     readonly name: string;
@@ -108,6 +112,7 @@ export interface HostSettingsHeld {
     };
     readonly version: string;
 }
+export declare function hookEnvNamesOf(hooks: unknown): readonly string[];
 export interface HostTurnSettingsJudges {
     readonly materialize: HostResolvedMaterializer;
     readonly memoryOffDeclared: typeof MemoryOffDeclared;
@@ -137,6 +142,7 @@ export declare function hostSettingsAcceptCurrent(product: HostTurnSettings, con
 export declare function hostSettingsSelfCheck(product: HostTurnSettings): readonly HostSuppliedKey[];
 export declare const hostProjectionNotice: () => HostSettingNotice;
 export declare const hostFileHistoryRestoreNotice: () => HostSettingNotice;
+export declare const hostStyleNotAppliedNotice: (cause: "oversize" | "unreadable", limit: number) => HostSettingNotice;
 export declare class HostSettingsRefused extends Error {
     readonly notice: HostSettingNotice;
     constructor(n: HostSettingNotice);

package/dist/hostTurnSettings.js

@@ -1,5 +1,6 @@
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG } from './generated/settingsSchemaFns.js';
 import { hostLog } from './host.js';
+import { isEngineFiredHookEvent } from './pluginHooksWire.js';
 import { layerNotAppliedRefusesTurn, salvageSettingsHooksEntries } from './settingsHooksSalvage.js';
 import { ADOPTED_LAYERS, HOST_SETTINGS_LAYERS, HostSettingsSourceShapeError, TIGHTEN_ONLY_HOST_SETTINGS_LAYERS, permissionBucketOf, permissionRulesOf, MANAGED_READING_DISPOSITIONS, adoptHostSettingsRead, mintHostSettingsSession, readHostSettingsOnce, remintSameContent, sessionSnapshotOf, settingsValueOf, sourceOfRead, } from './hostSettingsSource.js';
 import { hooksWirePlan } from './hooksWireCaps.js';
@@ -13,8 +14,8 @@ import { assemblyRefusalOf } from './wireFailureShape.js';
 import { permissionRuleLayersOn } from './permissionsAllowGrantCapability.js';
 import { layerAdmissionReading, layerAdmitted } from './settingsLayerAdmission.js';
 import { SETTINGS_BUILD_LAYER_PARTS_UNREAD_NOTICE } from './generated/settingsSchemaFns.js';
-import { appendOwnElement, ownDataField } from './ownKey.js';
-export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory']);
+import { appendOwnElement, ownDataField, readOwnDataValue } from './ownKey.js';
+export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory', 'settings.env']);
 export const HOST_SETTING_CAUSES = Object.freeze([
     'carried',
     'entries_dropped',
@@ -44,6 +45,8 @@ const HOST_SETTING_NOTICE_TEXT = {
     'HS-STYLE-MISSING': (what) => renderMessage(msg('session.hostSettings.styleMissing', { name: what })),
     'HS-STYLE-SAFE': () => renderMessage(msg('session.hostSettings.styleSafeMode')),
     'HS-LAYER-PARTS-UNREAD': (line) => line,
+    'HS-STYLE-OVERSIZE': (what) => renderMessage(msg('session.hostSettings.styleOversize', { limit: what })),
+    'HS-STYLE-UNREADABLE': () => renderMessage(msg('session.hostSettings.styleUnreadable')),
 };
 const KEY_NOUN = {
     'settings.hooks': 'the hooks',
@@ -52,6 +55,7 @@ const KEY_NOUN = {
     'settings.outputStyle': 'the output style',
     memory: 'auto-memory',
     fileHistory: 'file checkpoints',
+    'settings.env': 'the environment variables your HTTP hooks read',
 };
 const BASE_DISPOSITION = {
     carried: 'carry',
@@ -204,6 +208,98 @@ function webSearchArm(src, side) {
         notices: [notice('HS-WEBSEARCH-MALFORMED', 'turn', webSearchVerdictMessage(verdict, 'submit') ?? '')],
     };
 }
+function ownElementsOf(v) {
+    if (!Array.isArray(v))
+        return [];
+    const len = readOwnDataValue(v, 'length');
+    if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < len; i++)
+        appendOwnElement(out, readOwnDataValue(v, String(i)));
+    return out;
+}
+export function hookEnvNamesOf(hooks) {
+    const out = [];
+    if (!isRecordShape(hooks))
+        return out;
+    for (const event of Object.keys(hooks)) {
+        if (!isEngineFiredHookEvent(event))
+            continue;
+        for (const group of ownElementsOf(readOwnDataValue(hooks, event))) {
+            if (!isRecordShape(group))
+                continue;
+            for (const entry of ownElementsOf(readOwnDataValue(group, 'hooks'))) {
+                if (!isRecordShape(entry) || readOwnDataValue(entry, 'type') !== 'http')
+                    continue;
+                for (const name of ownElementsOf(readOwnDataValue(entry, 'allowedEnvVars'))) {
+                    if (typeof name === 'string' && !out.includes(name))
+                        appendOwnElement(out, name);
+                }
+            }
+        }
+    }
+    return out;
+}
+function hookEnvLayerOf(names, env) {
+    const layer = {};
+    let n = 0;
+    for (const name of names) {
+        const v = readOwnDataValue(env, name);
+        if (typeof v !== 'string')
+            continue;
+        Object.defineProperty(layer, name, { value: v, enumerable: true, writable: true, configurable: true });
+        n++;
+    }
+    return n > 0 ? freeze(layer) : undefined;
+}
+function hookEnvConsistent(env, hooks) {
+    if (env === undefined)
+        return true;
+    try {
+        if (!isRecordShape(env))
+            return false;
+        const keys = Reflect.ownKeys(env);
+        if (keys.length === 0)
+            return false;
+        const names = hookEnvNamesOf(hooks);
+        return keys.every((k) => typeof k === 'string' && names.includes(k) && typeof readOwnDataValue(env, k) === 'string');
+    }
+    catch {
+        return false;
+    }
+}
+function envArm(src, hooksCarried) {
+    const key = 'settings.env';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let env;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'env'))
+            throw badSource(key, "{ env } with the host environment (pass 'none' where there is none)");
+        env = v.env;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (!isRecordShape(env))
+        throw badSource(key, '{ env } where env is the environment record');
+    let layer;
+    try {
+        layer = hookEnvLayerOf(hookEnvNamesOf(hooksCarried), env);
+    }
+    catch {
+        return unreadableArm(key);
+    }
+    return layer === undefined ? emptyArm(key) : carriedArm(key, layer);
+}
 function memoryArm(src, side, judge) {
     const key = 'memory';
     if (src.kind === 'missing')
@@ -336,7 +432,7 @@ function outputStyleArm(src, side) {
     const reminder = state.ok && state.value === 'present' ? ownDataOf(body, 'turnReminder') : undefined;
     if (text !== undefined && text.ok && typeof text.value === 'string' && reminder !== undefined && reminder.ok && (reminder.value === undefined || typeof reminder.value === 'string')) {
         const facts = freeze({ name, body: text.value, ...(reminder.value !== undefined ? { turnReminder: reminder.value } : {}) });
-        return { ...carriedArm(key, name), facts };
+        return text.value.trim() === '' ? { ...emptyArm(key), facts } : { ...carriedArm(key, text.value), facts };
     }
     return {
         row: freeze({ key, cause: 'source_unreadable', disposition: 'withhold_notice' }),
@@ -709,6 +805,7 @@ export function buildHostTurnSettings(input, judges) {
     const outputStyle = outputStyleArm(read('outputStyle'), side);
     const memory = memoryArm(read('memory'), side, judges.memoryOffDeclared);
     const fileHistory = fileHistoryArm(read('fileHistory'));
+    const envSource = read('env');
     let resolved = resolvedArm;
     let armsByKey = [hooks, resolved, webSearch, outputStyle, memory, fileHistory];
     if (side.kind === 'read' && MANAGED_READING_DISPOSITIONS[side.read.managed].commit === 'refuse') {
@@ -765,7 +862,10 @@ export function buildHostTurnSettings(input, judges) {
         armsByKey = [{ ...mark(armsByKey[0]), ...(hooks.plan !== undefined ? { plan: hooks.plan } : {}) }, mark(armsByKey[1]), armsByKey[2], armsByKey[3], armsByKey[4], armsByKey[5]];
         appendOwnElement(heldNotices, notice('HS-HELD-PREVIOUS', 'diagnostic'));
     }
-    const arms = armsByKey;
+    const hooksFinal = armsByKey[0];
+    const hooksToCarry = hooksFinal.row.disposition === 'carry' || hooksFinal.row.disposition === 'carry_partial' || hooksFinal.row.disposition === 'hold_for_consent' ? hooksFinal.carried : undefined;
+    const env = envArm(envSource, hooksToCarry);
+    const arms = [...armsByKey, env];
     const rows = freeze(arms.map((a) => a.row));
     const resolvedOut = arms[1]?.row.disposition === 'carry' || arms[1]?.row.disposition === 'carry_partial' || arms[1]?.row.disposition === 'hold_for_consent' ? resolvedCarried : undefined;
     const permissionsRow = arms[1]?.row;
@@ -790,8 +890,10 @@ export function buildHostTurnSettings(input, judges) {
         ...(carriedOf(3) !== undefined ? { outputStyle: carriedOf(3) } : {}),
         ...(carriedOf(4) !== undefined ? { memory: 'off' } : {}),
         ...(carriedOf(5) !== undefined ? { fileHistory: 'disabled' } : {}),
+        ...(carriedOf(6) !== undefined ? { env: carriedOf(6) } : {}),
     });
-    const styleFacts = arms[3]?.row.disposition === 'carry' ? outputStyle.facts : undefined;
+    const styleDisposition = arms[3]?.row.disposition;
+    const styleFacts = styleDisposition === 'carry' || styleDisposition === 'nothing_to_carry' ? outputStyle.facts : undefined;
     const product = { verdict, rows, notices, hooks: hooks.plan, carried, session: nextSession, outputStyle: styleFacts, held };
     if (resolvedError !== undefined && resolvedOut !== undefined)
         Object.defineProperty(product, RESOLVED_DEFERRED_ERROR, { value: resolvedError, enumerable: false });
@@ -910,6 +1012,7 @@ export function hostSettingsSelfCheck(product) {
 }
 export const hostProjectionNotice = () => notice('HS-PROJECTION', 'turn');
 export const hostFileHistoryRestoreNotice = () => notice('HS-FILEHISTORY-RESTORE', 'turn');
+export const hostStyleNotAppliedNotice = (cause, limit) => cause === 'oversize' ? notice('HS-STYLE-OVERSIZE', 'turn', String(limit)) : notice('HS-STYLE-UNREADABLE', 'turn');
 export class HostSettingsRefused extends Error {
     notice;
     constructor(n) {
@@ -985,6 +1088,8 @@ export function hostTurnSettingsOf(v, depth = 'full') {
             return undefined;
         if (Object.hasOwn(carried, 'hooks') && carried.hooks !== undefined && !hooksPassJudge(carried.hooks))
             return undefined;
+        if (!hookEnvConsistent(Object.hasOwn(carried, 'env') ? carried.env : undefined, Object.hasOwn(carried, 'hooks') ? carried.hooks : undefined))
+            return undefined;
         return shaped;
     }
     catch {
@@ -1225,6 +1330,8 @@ function intakeSnapshotUnguarded(product, onResolved) {
         return undefined;
     if (values.hooks !== undefined && !hooksPassJudge(values.hooks))
         return undefined;
+    if (!hookEnvConsistent(values.env, values.hooks))
+        return undefined;
     const v = ownDataOf(product, 'verdict');
     if (!v.ok)
         return undefined;

package/dist/i18n/messages.en.d.ts

@@ -117,6 +117,7 @@ declare const EN: {
     'model.subagent.ambiguous': string;
     'model.catalogDefault.refused.named': string;
     'model.catalogDefault.refused.select': string;
+    'session.sync.pushRowBitsWriterSide': string;
     'session.devices.laneAbsent': string;
     'session.devices.laneUnreported': string;
     'session.devices.verbsOff': string;
@@ -130,6 +131,24 @@ declare const EN: {
     'session.engine.dispatch.scopeUnproven': string;
     'session.engine.dispatch.unresolved': string;
     'session.engine.dispatch.sessionAmbiguous': string;
+    'session.mcpReconnect.notRunning': string;
+    'session.mcpReconnect.unsupported': string;
+    'session.mcpReconnect.notFound': string;
+    'session.mcpReconnect.invalid': string;
+    'session.mcpReconnect.failed': string;
+    'session.mcpReconnect.noSession': string;
+    'session.mcpReconnect.unavailable': string;
+    'session.mcpReconnect.accepted.one': string;
+    'session.mcpReconnect.accepted.other': string;
+    'session.mcpReconnect.refused.untouched': string;
+    'session.mcpReconnect.refused.noTools': string;
+    'session.mcpReconnect.refused.listed.one': string;
+    'session.mcpReconnect.refused.listed.other': string;
+    'session.mcpReconnect.undeclared': string;
+    'session.mcpReconnect.unsettled': string;
+    'session.mcpReconnect.reasonTail': string;
+    'session.mcpFailure.reauthorizeSuffix': string;
+    'session.mcpFailure.serverDownSuffix': string;
     'config.cloudLogin.accessDenied': string;
     'config.cloudLogin.expiredToken': string;
     'config.cloudLogin.invalidGrant': string;
@@ -252,6 +271,7 @@ declare const EN: {
     'approval.settle.cause.streamDisconnected': string;
     'approval.settle.cause.undeliverable': string;
     'approval.resolution.engineUnavailable': string;
+    'approval.allowNote.notCarried': string;
     'approval.decide.requiresBinding': string;
     'approval.decide.unboundWayOut.armed': string;
     'approval.decide.unboundWayOut.none': string;
@@ -261,6 +281,8 @@ declare const EN: {
     'approval.rowUnresumable.askNotSurfaced': string;
     'approval.park.stillParked': string;
     'approval.park.refusedNotResumable': string;
+    'approval.park.resume.card': string;
+    'approval.park.resume.speak': string;
     'approval.park.argsFromModelCall': string;
     'approval.park.questionsFromModelCall': string;
     'approval.policyDeny.denyRule': string;
@@ -269,6 +291,7 @@ declare const EN: {
     'approval.policyDeny.tail': string;
     'approval.decision.grantChanged': string;
     'approval.decision.answerInvalid': string;
+    'approval.editRefusal.line': string;
     'approval.decision.settledElsewhereContrary.deniedFirst': string;
     'approval.decision.settledElsewhereContrary.approvedFirst': string;
     'approval.decision.unconfirmedAfterRetry': string;
@@ -634,6 +657,8 @@ declare const EN: {
     'session.hostSettings.heldPrevious': string;
     'session.hostSettings.styleMissing': string;
     'session.hostSettings.styleSafeMode': string;
+    'session.hostSettings.styleOversize': string;
+    'session.hostSettings.styleUnreadable': string;
     'model.identity.lane.processEnv': string;
     'model.identity.lane.settingsEnv': string;
     'model.identity.lane.modelCatalogFile': string;
@@ -708,6 +733,27 @@ declare const EN: {
     'notice.peer.inbound.resupplyExhausted': string;
     'notice.peer.inbound.other': string;
     'notice.peer.inbound.cause': string;
+    'notice.sessionBox.peer.another': string;
+    'notice.sessionBox.peer.anotherStart': string;
+    'notice.sessionBox.inbox.one': string;
+    'notice.sessionBox.inbox.many': string;
+    'notice.sessionBox.inbox.urgent': string;
+    'notice.sessionBox.inbox.resupplied': string;
+    'notice.sessionBox.delivery.delivered': string;
+    'notice.sessionBox.delivery.held': string;
+    'notice.sessionBox.delivery.heldByPolicy': string;
+    'notice.sessionBox.delivery.denied': string;
+    'notice.sessionBox.delivery.refused': string;
+    'notice.sessionBox.delivery.expired': string;
+    'notice.sessionBox.delivery.dropped': string;
+    'notice.sessionBox.delivery.droppedPlain': string;
+    'notice.sessionBox.delivery.other': string;
+    'notice.sessionBox.idle.finished': string;
+    'notice.sessionBox.idle.finishedDetail': string;
+    'notice.sessionBox.idle.exited': string;
+    'notice.sessionBox.idle.unavailable': string;
+    'notice.sessionBox.idle.expired': string;
+    'notice.sessionBox.idle.other': string;
     'notice.peer.held.deliveredApproved': string;
     'notice.peer.held.deliveredRejudged': string;
     'notice.peer.held.droppedRejudged': string;
@@ -736,6 +782,7 @@ declare const EN: {
     'notice.task.lateApproval': string;
     'notice.task.haltUnconsumed': string;
     'notice.steering.parkedInputBlocked': string;
+    'notice.model.capabilityDowngraded.image': string;
     'rules.refusal.sentence.one': string;
     'rules.refusal.sentence.other': string;
     'rules.refusal.item': string;
@@ -818,6 +865,10 @@ declare const EN: {
     'session.steerRefusal.advice': string;
     'session.steerRefusal.hostQueue.queued': string;
     'session.steerRefusal.hostQueue.dropped': string;
+    'session.interruptRefusal.nothingInFlight': string;
+    'session.interruptRefusal.notHeld': string;
+    'session.interruptRefusal.notRunning': string;
+    'session.interruptRefusal.unrecognised': string;
     'session.permissionModeSwitch.applied': string;
     'session.permissionModeSwitch.folded': string;
     'session.permissionModeSwitch.reason.entryFloor': string;
@@ -954,6 +1005,8 @@ declare const EN: {
     'notice.failure.headline.parked': string;
     'notice.failure.headline.internal': string;
     'notice.failure.headline.causeUnreadable': string;
+    'notice.streamEnded.emptyLegs.headline': string;
+    'notice.streamEnded.consecutiveFailures.headline': string;
     'notice.failure.quota.fiveHour': string;
     'notice.failure.quota.weekly': string;
     'notice.failure.quota.budgetPersonal': string;
@@ -1108,6 +1161,16 @@ declare const EN: {
     'notice.wireRefusal.sessionIdRetired.folded': string;
     'notice.wireRefusal.runConcurrencyCap.head': string;
     'notice.wireRefusal.runConcurrencyCap.unknownWait': string;
+    'notice.wireRefusal.unreadMembers': string;
+    'notice.wireRefusal.unreadMembers.folded': string;
+    'notice.wireRefusal.unreadMembers.where': string;
+    'notice.wireRefusal.unreadMembers.remedy': string;
+    'notice.wireRefusal.unreadMembers.folded.remedy': string;
+    'notice.wireRefusal.unreadMembers.part.settingsHooks': string;
+    'notice.wireRefusal.unreadMembers.part.settingsEnv': string;
+    'notice.wireRefusal.unreadMembers.part.settingsOther': string;
+    'notice.wireRefusal.unreadMembers.part.mcpTransport': string;
+    'notice.wireRefusal.unreadMembers.part.a2aHeaders': string;
     'notice.wireRefusal.unsupportedRule': string;
     'notice.wireRefusal.unsupportedRule.other': string;
     'notice.wireRefusal.unsupportedRule.stored': string;
@@ -1169,6 +1232,8 @@ declare const EN: {
     'session.subagent.delegatedPrompt.absence.forbidden': string;
     'session.subagent.delegatedPrompt.absence.promptAbsent': string;
     'session.subagent.delegatedPrompt.absence.unknown': string;
+    'rules.sessionPolicy.remove.loosenForbiddenStem': string;
+    'rules.sessionPolicy.remove.loosenForbidden': string;
     'rules.sessionPolicy.tighten.unknown.sessionOwnerless.noIdentity': string;
     'rules.sessionPolicy.tighten.unknown.storeCorrupt.noOperator': string;
     'rules.sessionPolicy.deployment.noOperator.readStoreCorrupt': string;
@@ -1178,6 +1243,9 @@ declare const EN: {
     'config.hooks.plan.reason.compactionLocalFallback': string;
     'config.hooks.plan.reason.keyNotRead': string;
     'config.hooks.plan.disableAllHooks': string;
+    'config.hooks.plan.reason.closedUntrusted': string;
+    'config.hooks.plan.reason.closedGovernanceUnreadable': string;
+    'config.hooks.plan.reason.closedDisableAll': string;
     'config.hooks.plan.keyNotRead.oneKey': string;
     'config.hooks.plan.keyNotRead.manyKeys': string;
     'config.hooks.plan.keyNotRead.more': string;
@@ -1224,8 +1292,11 @@ declare const EN: {
     'config.mods.loader.failed': string;
     'config.mods.loader.failedNoReason': string;
     'config.mods.refusal.by': string;
+    'config.mods.request.by': string;
     'config.mods.rewrite.resultInPlace': string;
     'config.mods.rewrite.inputBy': string;
+    'config.mods.session.unreadable': string;
+    'config.mods.session.unarmed': string;
     'follow.notFollowed.headRun': string;
     'follow.notFollowed.headTurn': string;
     'follow.notFollowed.reason.exhaustedDraining': string;
@@ -1337,6 +1408,18 @@ declare const EN: {
     'localEngine.restartOutcome.pendingBusy': string;
     'localEngine.restartOutcome.failedPrepare': string;
     'localEngine.restartOutcome.failedDown': string;
+    'session.devices.repoint.done': string;
+    'session.devices.repoint.unverified': string;
+    'session.devices.repoint.undetermined': string;
+    'session.devices.repoint.partial': string;
+    'session.devices.repoint.storeFailed': string;
+    'session.devices.repoint.refused.addressInvalid': string;
+    'session.devices.repoint.refused.sameAddress': string;
+    'session.devices.repoint.refused.recordAbsent': string;
+    'session.devices.repoint.refused.recordNotActive': string;
+    'session.devices.repoint.refused.recordUnreadable': string;
+    'session.devices.repoint.refused.targetOccupied': string;
+    'session.devices.repoint.refused.unarmed': string;
 };
 export declare const EN_MESSAGES: Readonly<typeof EN>;
 export type MessageKey = keyof typeof EN;