@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/hooksWireCaps.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, hookEntryTypeWordOf, 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, ...hookEntryTypeWordOf(entry), 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;

package/dist/hostSettingNoticeArm.d.ts

@@ -0,0 +1,3 @@
+import { type HostSettingNotice } from './hostTurnSettings.js';
+import type { HostSettingNoticeChromeEvent } from './seam.js';
+export declare function hostSettingNoticeEventsOf(notices: readonly HostSettingNotice[] | null | undefined): readonly HostSettingNoticeChromeEvent[];

package/dist/hostSettingNoticeArm.js

@@ -0,0 +1,12 @@
+import { hostSettingNoticeCopiesOf } from './hostTurnSettings.js';
+import { appendOwnElement } from './ownKey.js';
+export function hostSettingNoticeEventsOf(notices) {
+    const out = [];
+    const copies = hostSettingNoticeCopiesOf(notices);
+    for (let i = 0; i < copies.length; i++) {
+        const copy = copies[i];
+        if (copy !== undefined)
+            appendOwnElement(out, Object.freeze({ kind: 'host_setting_notice', laneProof: Object.freeze({ lane: 'main' }), ...copy }));
+    }
+    return Object.freeze(out);
+}

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;
@@ -27,6 +27,8 @@ export interface HostSettingNotice {
     readonly id: HostSettingNoticeId;
     readonly plane: HostSettingPlane;
     readonly text: string;
+    readonly key?: HostSuppliedKey;
+    readonly cause?: HostSettingCause;
 }
 export type HostTurnVerdict = {
     readonly kind: 'send';
@@ -61,6 +63,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 +88,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 +114,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 +144,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);
@@ -160,6 +168,7 @@ export interface HostIntakeSnapshot {
         readonly error: {} | null | undefined;
     } | undefined;
 }
+export declare function hostSettingNoticeCopiesOf(notices: readonly HostSettingNotice[] | null | undefined): readonly HostSettingNotice[];
 export declare function hostIntakeSnapshotOf(product: HostTurnSettings, onResolved?: (resolved: HostSettingsCarried['resolved']) => void): HostIntakeSnapshot | undefined;
 export declare function hostSettingsRefusedError(n: HostSettingNotice, intake: HostIntakeSnapshot, firstSeatedKey: HostSuppliedKey | undefined): HostSettingsRefused;
 export declare const UNWIRED_HOST_TURN_SETTINGS: HostTurnSettings;

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,16 +862,20 @@ 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;
     const permissionsRead = permissionsRow !== undefined && permissionsRow.disposition !== 'refuse_turn' && permissionsRow.disposition !== 'unwired' && permissionsRow.cause !== 'no_source';
     const partsNotices = side.kind === 'read' ? tightenOnlyLayerNotices(side.read, permissionsRead) : [];
-    const notices = freeze([...arms.flatMap((a) => a.notices), ...notLoadedNotices, ...heldNotices, ...partsNotices]);
-    const refusal = arms.find((a) => a.row.disposition === 'refuse_turn');
-    const verdict = refusal !== undefined
-        ? freeze({ kind: 'refuse', notice: refusal.notices[0] ?? notices.find((n) => n.plane === 'turn') ?? notice('HS-PROJECTION', 'turn') })
+    const armNotices = arms.map((a) => a.notices.map((n) => freeze({ ...n, key: a.row.key, cause: a.row.cause })));
+    const notices = freeze([...armNotices.flat(), ...notLoadedNotices, ...heldNotices, ...partsNotices]);
+    const refusalAt = arms.findIndex((a) => a.row.disposition === 'refuse_turn');
+    const verdict = refusalAt >= 0
+        ? freeze({ kind: 'refuse', notice: armNotices[refusalAt]?.[0] ?? notices.find((n) => n.plane === 'turn') ?? notice('HS-PROJECTION', 'turn') })
         : consentKey !== undefined
             ? freeze({ kind: 'hold', consentKey, notice: notLoadedNotices[0] })
             : freeze({ kind: 'send' });
@@ -790,8 +891,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 +1013,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 +1089,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 {
@@ -1106,7 +1212,39 @@ function noticeCopyOf(n) {
     const text = ownDataOf(n, 'text');
     if (!id.ok || !plane.ok || !text.ok || typeof id.value !== 'string' || typeof plane.value !== 'string' || typeof text.value !== 'string')
         return undefined;
-    return freeze({ id: id.value, plane: plane.value, text: text.value });
+    if (plane.value !== 'turn' && plane.value !== 'session' && plane.value !== 'diagnostic')
+        return undefined;
+    const key = ownDataOf(n, 'key');
+    const cause = ownDataOf(n, 'cause');
+    const keyWord = key.ok && typeof key.value === 'string' && HOST_SUPPLIED_KEYS.includes(key.value) ? key.value : undefined;
+    const causeWord = cause.ok && typeof cause.value === 'string' && HOST_SETTING_CAUSES.includes(cause.value) ? cause.value : undefined;
+    return freeze({
+        id: id.value,
+        plane: plane.value,
+        text: text.value,
+        ...(keyWord !== undefined ? { key: keyWord } : {}),
+        ...(causeWord !== undefined ? { cause: causeWord } : {}),
+    });
+}
+export function hostSettingNoticeCopiesOf(notices) {
+    const out = [];
+    try {
+        if (!Array.isArray(notices))
+            return freeze(out);
+        const len = ownDataOf(notices, 'length');
+        if (!len.ok || typeof len.value !== 'number')
+            return freeze(out);
+        for (let i = 0; i < len.value; i++) {
+            const e = ownDataOf(notices, String(i));
+            const copy = e.ok ? noticeCopyOf(e.value) : undefined;
+            if (copy !== undefined)
+                appendOwnElement(out, copy);
+        }
+    }
+    catch {
+        return freeze(out);
+    }
+    return freeze(out);
 }
 function turnNoticesOf(product) {
     try {
@@ -1225,6 +1363,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/humanTurnRead.js

@@ -42,7 +42,17 @@ const strArray = (v) => ownArray(v).map(str);
 const sizeOf = (v) => (v === null ? null : typeof v === 'number' ? v : bad());
 const posInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 1 ? v : bad());
 const natInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : bad());
-const NOT_INCLUDED_REASON_LIST = ['too-large', 'unreadable', 'read-denied', 'approval-required', 'server-not-connected', 'resource-not-listed', 'read-failed'];
+const NOT_INCLUDED_REASON_LIST = [
+    'too-large',
+    'unreadable',
+    'read-denied',
+    'approval-required',
+    'server-not-connected',
+    'resource-not-listed',
+    'read-failed',
+    'tools-elsewhere',
+    'tools-location-unconfirmed',
+];
 const notIncludedReasonsExhaustive = true;
 void notIncludedReasonsExhaustive;
 const NOT_INCLUDED_REASONS = new Set(NOT_INCLUDED_REASON_LIST);