@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/hooksWireCaps.js

@@ -1,7 +1,7 @@
 import { engineCapNestedTrue, engineCapState, engineCapString, engineCapValue } from './engineCapsCache.js';
 import { hooksReaderNotReadKeys } from './hooksReaderGenerations.js';
 import { msg, renderMessage } from './i18n/translate.js';
-import { capForDisplay, collapseLabel } from './fleetTaskDesc.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 import { hostLog } from './host.js';
 import { faultText } from './hostCallbackGuard.js';
 import { HostSettingsSourceShapeError, MANAGED_READING_DISPOSITIONS, mergedBooleanOf, nonManagedLayerDown, readHostSettingsOnce } from './hostSettingsSource.js';
@@ -9,7 +9,7 @@ import { admittedLayers, layerAdmissionWord } from './settingsLayerAdmission.js'
 import { guardedRead, readOwnDataValue } from './ownKey.js';
 import { HOOK_SETTINGS_SOURCE_TEXT, hooksSalvageMaskOf, salvageSettingsHooksEntries, settingsHooksSalvageNotice } from './settingsHooksSalvage.js';
 import { submissionOriginOf } from './request/submissionIdentity.js';
-import { createSettingsHookJudge, decidePluginHooks, decideSessionHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, hooksWirePlanShapeOf, occupancyOf, } from './pluginHooksWire.js';
+import { createSettingsHookJudge, decidePluginHooks, decideSessionHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, hooksWirePlanShapeOf, isEngineFiredHookEvent, occupancyOf, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { applyHttpHookPolicy, httpHookAdmittedSources, readHttpHookPolicy, wireHasHttpEntry } from './httpHookPolicy.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
@@ -300,6 +300,32 @@ function withheldRowsOf(candidates, trust, layers) {
     }
     return rows;
 }
+function closedDropRowsOf(source, doc, reason) {
+    const rows = [];
+    try {
+        const hooks = readOwnDataValue(doc, 'hooks');
+        if (typeof hooks !== 'object' || hooks === null || Array.isArray(hooks))
+            return rows;
+        for (const event of Object.keys(hooks)) {
+            const groups = readOwnDataValue(hooks, event);
+            if (!Array.isArray(groups))
+                continue;
+            groups.forEach((group, groupIndex) => {
+                if (typeof group !== 'object' || group === null)
+                    return;
+                const entries = readOwnDataValue(group, 'hooks');
+                if (!Array.isArray(entries))
+                    return;
+                entries.forEach((_entry, hookIndex) => {
+                    rows.push({ source, event, groupIndex, hookIndex, reason, notRun: true });
+                });
+            });
+        }
+    }
+    catch {
+    }
+    return rows;
+}
 function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppressedLocally, readerNotRead, compactionOnShell = false) {
     const settingsDropped = [];
     const settingsVerdicts = [];
@@ -333,6 +359,8 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
     });
     const closedPlan = (reason) => {
         closedBy = reason;
+        for (const source of ALL_HOOK_SOURCES)
+            settingsDropped.push(...closedDropRowsOf(source, read.layers[source].doc, reason));
         sessionReader = read.sessionHooks.state;
         const pr = read.plugins;
         if (pr.reading === undefined)
@@ -472,6 +500,8 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
             settingsDropped.push(...kept.drops);
             settingsVerdicts.push(...kept.verdicts);
             settingsExcluded.push(...kept.excluded);
+            if (!isEngineFiredHookEvent(event))
+                continue;
             settingsStripped += kept.stripped;
             if (kept.groups.length === 0)
                 continue;
@@ -555,8 +585,9 @@ export function fleetHookFailureNoticeCapable(baseUrl) {
 export const HOOK_FAILURE_WARN_PREFIX = 'Hook error';
 export function hookFailureNoticeText(n) {
     const code = n.exitCode !== undefined ? `exit ${n.exitCode}` : n.reason;
-    const name = collapseLabel(n.hookName);
-    const tail = n.stderr !== undefined ? `: ${collapseLabel(n.stderr)}` : '';
+    const fold = (s) => s.replace(/\s+/g, ' ').trim();
+    const name = fold(n.hookName);
+    const tail = n.stderr !== undefined ? `: ${fold(n.stderr)}` : '';
     const line = `${HOOK_FAILURE_WARN_PREFIX}: ${name} (${code})${tail}`;
     return capForDisplay(line, MAX_HOOK_NOTICE_TEXT_CHARS);
 }

package/dist/hostSettingsSource.js

@@ -550,6 +550,8 @@ export function adoptHostSettingsRead(read, session, allowAdmitted = () => true,
                 return true;
             if (LOADED.has(c.status))
                 return false;
+            if (c.status === 'absent')
+                return false;
             return !(c.status === 'empty' && c.emptyKind === 'empty-object');
         });
         trusted = !newIssue && !lost && !anyMalformed;

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;