@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/hooksWireCaps.js

@@ -1,10 +1,16 @@
 import { engineCapNestedTrue, engineCapState, engineCapValue } from './engineCapsCache.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { capForDisplay, collapseLabel } from './fleetTaskDesc.js';
-import { hostLog, hostSettings } from './host.js';
-import { hooksSalvageMaskOf, salvageSettingsHooksEntries, settingsHooksSalvageNotice } from './settingsHooksSalvage.js';
+import { hostLog } from './host.js';
+import { faultText } from './hostCallbackGuard.js';
+import { HostSettingsSourceShapeError, MANAGED_READING_DISPOSITIONS, mergedBooleanOf, nonManagedLayerDown, readHostSettingsOnce } from './hostSettingsSource.js';
+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 { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
+import { applyHttpHookPolicy, httpHookAdmittedSources, readHttpHookPolicy, wireHasHttpEntry } from './httpHookPolicy.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, } from './goalStopHook.js';
 const EDITABLE_HOOK_SOURCES = ['userSettings', 'projectSettings', 'localSettings'];
@@ -18,96 +24,13 @@ function hooksLockedToPluginOnly(policyValue) {
         return policyValue.includes('hooks');
     return false;
 }
-let warnedNoMergedReader = new WeakSet();
-const NO_MERGED_READER_WARNING = 'client-core: the installed settings port does not implement mergedDisableAllHooks() — ' +
-    'a disableAllHooks set in user, project, local or flag settings is not applied to hooks sent to the engine ' +
-    '(only a managed-settings disableAllHooks is). Implement SettingsPort.mergedDisableAllHooks() to return ' +
-    'the effective merged value.';
-function nonManagedDisableAllHooks(settings) {
-    try {
-        if (typeof settings.mergedDisableAllHooks === 'function')
-            return settings.mergedDisableAllHooks() === true;
-    }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: merged disableAllHooks read threw — fail-closed (only policySettings hooks projected to the engine): ${String(err)}`);
-        return true;
-    }
-    if (!warnedNoMergedReader.has(settings)) {
-        warnedNoMergedReader.add(settings);
-        hostLog('warn', NO_MERGED_READER_WARNING);
-    }
-    return false;
-}
-const HOOKS_STARTUP_MODES = ['safe', 'bare'];
-const _startupModesPin = [true, true];
-void _startupModesPin;
-function describeStartupModeValue(v) {
-    if (v === null)
-        return 'null';
-    if (typeof v === 'string')
-        return JSON.stringify(v.length > 40 ? `${v.slice(0, 40)}…` : v);
-    return typeof v;
-}
-function startupModeWord(settings) {
-    let v;
-    try {
-        const member = settings.hooksStartupMode;
-        if (member === undefined)
-            return undefined;
-        if (typeof member !== 'function') {
-            hostLog('debug', `hooksWireCaps: hooksStartupMode is ${describeStartupModeValue(member)}, not a method — treated as neither safe nor bare mode (settings hooks not narrowed)`);
-            return undefined;
-        }
-        v = member.call(settings);
-    }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: hooksStartupMode() threw — treated as neither safe nor bare mode (settings hooks not narrowed): ${String(err)}`);
-        return undefined;
-    }
-    if (v === undefined)
-        return undefined;
-    const word = HOOKS_STARTUP_MODES.find((w) => w === v);
-    if (word !== undefined)
-        return word;
-    hostLog('debug', `hooksWireCaps: hooksStartupMode() returned ${describeStartupModeValue(v)}, which is neither 'safe' nor 'bare' — treated as neither mode (settings hooks not narrowed)`);
-    return undefined;
-}
-const MANAGED_POLICY_STATES = ['absent', 'in-effect', 'unreadable'];
-const _managedPolicyStatesPin = [true, true];
-void _managedPolicyStatesPin;
-function managedPolicyUnreadable(settings) {
-    try {
-        const member = settings.managedPolicyReading;
-        if (member === undefined)
-            return false;
-        if (typeof member !== 'function') {
-            hostLog('debug', `hooksWireCaps: managedPolicyReading is ${describeStartupModeValue(member)}, not a method — fail-closed (no hooks projected to the engine)`);
-            return true;
-        }
-        const r = member.call(settings);
-        const state = typeof r === 'object' && r !== null && !Array.isArray(r) ? r.state : undefined;
-        const word = MANAGED_POLICY_STATES.find((w) => w === state);
-        if (word === 'absent' || word === 'in-effect')
-            return false;
-        if (word === 'unreadable') {
-            hostLog('debug', 'hooksWireCaps: managed policy layer reported unreadable — fail-closed (no hooks projected to the engine)');
-            return true;
-        }
-        hostLog('debug', `hooksWireCaps: managedPolicyReading() returned ${describeStartupModeValue(state)} as its state, which is none of 'absent' / 'in-effect' / 'unreadable' — fail-closed (no hooks projected to the engine)`);
-        return true;
-    }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: managedPolicyReading() threw — fail-closed (no hooks projected to the engine): ${String(err)}`);
-        return true;
-    }
-}
 const NO_LAYER = Object.freeze({ hooks: null, mask: undefined });
 function layerOfDoc(source, doc) {
     try {
         return classifyLayer(source, doc);
     }
     catch (err) {
-        hostLog('debug', `hooksWireCaps: ${source} settings could not be read by the hooks reader — treated as no hooks from this source: ${String(err)}`);
+        hostLog('debug', `hooksWireCaps: ${source} settings could not be read by the hooks reader — treated as no hooks from this source: ${faultText(err)}`);
         return NO_LAYER;
     }
 }
@@ -123,71 +46,47 @@ function classifyLayer(source, doc) {
         return { hooks: null, mask: undefined, row };
     return { hooks: original, mask: hooksSalvageMaskOf(salvage.dropped), row };
 }
-function layerOfSource(source) {
+function layerOfSource(source, docOf) {
     let doc;
     try {
-        doc = hostSettings()?.getSettingsForSource(source);
+        doc = docOf(source);
     }
     catch (err) {
-        hostLog('debug', `hooksWireCaps: ${source} settings read threw — treated as no hooks from this source: ${String(err)}`);
+        hostLog('debug', `hooksWireCaps: ${source} settings could not be read — treated as no hooks from this source: ${faultText(err)}`);
         return NO_LAYER;
     }
     return layerOfDoc(source, doc);
 }
-let warnedNoPluginReader = new WeakSet();
-const NO_PLUGIN_READER_WARNING = 'client-core: the installed settings port does not implement enabledPluginHooks() — ' +
-    'plugin hooks are not sent to the engine and are not reported as not running. ' +
-    'Implement SettingsPort.enabledPluginHooks() to list the enabled plugins and their hooks.';
+class LayerUnreadable extends Error {
+    layer;
+    constructor(layer) {
+        super(`${layer} settings unreadable`);
+        this.layer = layer;
+    }
+}
 function guardPluginTraversal(run) {
     try {
         return run();
     }
     catch (err) {
-        hostLog('debug', `hooksWireCaps: plugin hook data threw while being read — no plugin hooks projected this turn: ${String(err)}`);
+        hostLog('debug', `hooksWireCaps: plugin hook data threw while being read — no plugin hooks projected this turn: ${faultText(err)}`);
         return undefined;
     }
 }
-function readPluginHooks(settings, warnIfAbsent) {
-    try {
-        if (typeof settings.enabledPluginHooks === 'function') {
-            const r = settings.enabledPluginHooks();
-            if (typeof r === 'object' && r !== null && Array.isArray(r.plugins)) {
-                return { state: 'present', reading: r };
-            }
-            hostLog('debug', 'hooksWireCaps: enabledPluginHooks() returned a malformed reading — no plugin hooks projected this turn');
-            return { state: 'failed' };
-        }
-    }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: enabledPluginHooks() threw — no plugin hooks projected this turn: ${String(err)}`);
-        return { state: 'failed' };
-    }
-    if (warnIfAbsent && !warnedNoPluginReader.has(settings)) {
-        warnedNoPluginReader.add(settings);
-        hostLog('warn', NO_PLUGIN_READER_WARNING);
-    }
-    return { state: 'absent' };
-}
-function readSessionHooks(settings) {
+function compactionOnShellOf(o) {
+    let raw;
     try {
-        const member = settings.sessionHooks;
-        if (member === undefined)
-            return { state: 'absent' };
-        if (typeof member !== 'function') {
-            hostLog('debug', 'hooksWireCaps: sessionHooks is not a method — no session hooks judged this turn');
-            return { state: 'failed' };
-        }
-        const r = member.call(settings);
-        const sources = typeof r === 'object' && r !== null ? r.sources : undefined;
-        if (Array.isArray(sources))
-            return { state: 'present', sources };
-        hostLog('debug', 'hooksWireCaps: sessionHooks() returned a malformed reading — no session hooks judged this turn');
-        return { state: 'failed' };
+        raw = o.compactionOnShell;
     }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: sessionHooks() threw — no session hooks judged this turn: ${String(err)}`);
-        return { state: 'failed' };
+    catch {
+        hostLog('debug', 'hooksWirePlan: compactionOnShell threw while being read — treated as absent (compaction hooks judged as before)');
+        return false;
     }
+    if (raw === undefined || raw === false)
+        return false;
+    if (raw !== true)
+        hostLog('debug', 'hooksWirePlan: compactionOnShell is not the boolean true — treated as absent (compaction hooks judged as before)');
+    return raw === true;
 }
 function suppressedLocallyOf(o) {
     let raw;
@@ -249,8 +148,20 @@ export function hooksForWire(opts) {
     throw usageError(given === undefined ? msg('config.hooks.forWire.planMissing') : msg('config.hooks.forWire.planNotPlan', { shape: hostValueShape(given) }));
 }
 const planShapeOf = hooksWirePlanShapeOf;
-export function hooksWirePlan(opts = {}) {
-    const o = opts ?? {};
+export function hooksWirePlan(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        throw new HostSettingsSourceShapeError('hooksWirePlan: pass { settings, ... } where settings is the HostSettingsSource for this turn.');
+    const o = opts;
+    let given;
+    try {
+        given = o.settings;
+    }
+    catch {
+        throw new HostSettingsSourceShapeError('hooksWirePlan: reading opts.settings threw — pass { settings, ... } where settings is the HostSettingsSource for this turn.');
+    }
+    const read = readHostSettingsOnce(given, 'hooksWirePlan');
+    for (const line of read.debug)
+        hostLog('debug', line);
     const owned = o.engineOwnedByThisShell;
     const engine = {
         ownedByThisShell: owned === true ? true : owned === false ? false : null,
@@ -274,7 +185,7 @@ export function hooksWirePlan(opts = {}) {
         const types = typesByEvent.get(event);
         return types === undefined || (typeof type === 'string' && types.has(type));
     };
-    return buildHooksWirePlan(engine, shellRuns, promptAuthoredByUserOf(o), suppressedLocallyOf(o));
+    return buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUserOf(o), suppressedLocallyOf(o), compactionOnShellOf(o));
 }
 function taskHooksCapability(baseUrl) {
     const v = engineCapValue(baseUrl, 'taskSettings');
@@ -305,17 +216,53 @@ function shellHookTypesOf(o) {
         return out;
     }
     catch (err) {
-        hostLog('debug', `hooksWirePlan: shellHookTypesByEvent is malformed — treated as absent (command and http hooks count as running on every reported event; prompt and agent hooks are not counted as running locally): ${String(err)}`);
+        hostLog('debug', `hooksWirePlan: shellHookTypesByEvent is malformed — treated as absent (command and http hooks count as running on every reported event; prompt and agent hooks are not counted as running locally): ${faultText(err)}`);
         return undefined;
     }
 }
 function promptAuthoredByUserOf(o) {
+    const origin = identityOriginOf(o);
+    if (origin === undefined)
+        return legacyPromptAuthoredByUserOf(o);
+    const derived = origin === 'user';
+    let v;
+    try {
+        v = o.promptAuthoredByUser;
+    }
+    catch {
+        hostLog('debug', 'hooksWirePlan: promptAuthoredByUser threw while being read — ignored, the submission identity decides');
+        return derived;
+    }
+    if (v === undefined || v === derived)
+        return derived;
+    hostLog('debug', v === true || v === false
+        ? `hooksWirePlan: promptAuthoredByUser (${String(v)}) conflicts with the submission identity (origin ${origin}) — the identity decides`
+        : 'hooksWirePlan: promptAuthoredByUser is not a boolean — ignored, the submission identity decides');
+    return derived;
+}
+function identityOriginOf(o) {
+    let raw;
+    try {
+        raw = o.identity;
+    }
+    catch {
+        hostLog('debug', 'hooksWirePlan: identity threw while being read — treated as absent (the promptAuthoredByUser slot decides, as before)');
+        return undefined;
+    }
+    if (raw === undefined || raw === null)
+        return undefined;
+    const origin = typeof raw === 'object' ? submissionOriginOf(raw) : undefined;
+    if (origin === undefined)
+        hostLog('debug', 'hooksWirePlan: identity is not a submission identity — treated as absent (the promptAuthoredByUser slot decides, as before)');
+    return origin;
+}
+function legacyPromptAuthoredByUserOf(o) {
     let v;
     try {
         v = o.promptAuthoredByUser;
     }
     catch (err) {
-        hostLog('debug', `hooksWirePlan: promptAuthoredByUser threw while being read — treated as written by the user: ${String(err)}`);
+        hostLog('debug', `hooksWirePlan: promptAuthoredByUser threw while being read — treated as written by the user: ${faultText(err)}`);
         return true;
     }
     if (v === false)
@@ -325,15 +272,44 @@ function promptAuthoredByUserOf(o) {
     }
     return true;
 }
-function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedLocally) {
+function layerWritesHooks(doc) {
+    const hooks = guardedRead(() => readOwnDataValue(doc, 'hooks'));
+    if (typeof hooks !== 'object' || hooks === null || Array.isArray(hooks))
+        return false;
+    try {
+        return Object.keys(hooks).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function withheldRowsOf(candidates, trust, layers) {
+    const rows = [];
+    for (const source of candidates) {
+        if (!layerWritesHooks(layers[source].doc))
+            continue;
+        if (layerAdmissionWord(source, trust, 'hooks') !== 'trust_withheld')
+            continue;
+        rows.push(Object.freeze({
+            source,
+            cause: 'trust_withheld',
+            notice: renderMessage(msg('config.hooks.layerWithheld.trust', { layer: HOOK_SETTINGS_SOURCE_TEXT[source] })),
+        }));
+    }
+    return rows;
+}
+function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppressedLocally, compactionOnShell = false) {
     const settingsDropped = [];
     const settingsVerdicts = [];
     const settingsExcluded = [];
     const settingsSalvage = [];
+    const httpPolicyDrops = [];
     let sessionVerdicts = [];
     let sessionReader = 'absent';
     let closedBy = null;
-    const judge = createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser);
+    let settingsSourcesNow = [];
+    let settingsWithheldNow = [];
+    const judge = createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser, compactionOnShell);
     let settingsStripped = 0;
     const planOf = (pluginReader, wire, verdicts = [], excluded = [], moduleVerdicts = []) => ({
         engine,
@@ -344,19 +320,22 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedL
         settingsVerdicts,
         settingsExcluded,
         settingsSalvage,
+        httpPolicyDrops: [...httpPolicyDrops],
         moduleVerdicts,
         sessionVerdicts,
         sessionReader,
         closedBy,
+        settingsSources: closedBy === null ? settingsSourcesNow : [],
+        settingsWithheld: closedBy === null ? settingsWithheldNow : [],
         wire,
     });
-    const closedPlan = (settings, reason) => {
+    const closedPlan = (reason) => {
         closedBy = reason;
-        sessionReader = readSessionHooks(settings).state;
-        const read = readPluginHooks(settings, false);
-        if (read.reading === undefined)
-            return planOf(read.state, undefined);
-        const reading = read.reading;
+        sessionReader = read.sessionHooks.state;
+        const pr = read.plugins;
+        if (pr.reading === undefined)
+            return planOf(pr.state, undefined);
+        const reading = pr.reading;
         const d = guardPluginTraversal(() => decidePluginHooks({
             plugins: reading.plugins,
             exclusion: reason,
@@ -368,64 +347,82 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedL
         }));
         if (d === undefined)
             return planOf('failed', undefined);
-        return planOf(read.state, undefined, d.verdicts, d.excluded);
+        return planOf(pr.state, undefined, d.verdicts, d.excluded);
     };
-    const settings = hostSettings();
-    if (settings === undefined)
-        return planOf('absent', undefined);
-    try {
-        if (settings.shouldSkipHookDueToTrust()) {
-            hostLog('debug', 'hooksWireCaps: workspace not trusted — no hooks projected to the engine');
-            return closedPlan(settings, 'workspace_untrusted');
-        }
-    }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: workspace trust check threw — fail-closed (no hooks projected to the engine): ${String(err)}`);
-        return closedPlan(settings, 'governance_unreadable');
-    }
-    if (managedPolicyUnreadable(settings))
-        return closedPlan(settings, 'governance_unreadable');
-    let policy = null;
-    let policyDoc;
-    try {
-        policyDoc = settings.getSettingsForSource('policySettings');
-        policy = policyDoc;
-    }
-    catch (err) {
-        hostLog('debug', `hooksWireCaps: policySettings read threw — fail-closed (no hooks projected to the engine): ${String(err)}`);
-        return closedPlan(settings, 'governance_unreadable');
-    }
+    if (read.trust === 'unreadable')
+        return closedPlan('governance_unreadable');
+    if (read.trust === 'declined') {
+        hostLog('debug', 'hooksWireCaps: workspace not trusted — no hooks projected to the engine');
+        return closedPlan('workspace_untrusted');
+    }
+    const managedReading = MANAGED_READING_DISPOSITIONS[read.managed];
+    if (managedReading.commit === 'refuse') {
+        hostLog('debug', `hooksWireCaps: managed policy layer reported ${read.managed} — fail-closed (no hooks projected to the engine)`);
+        return closedPlan('governance_unreadable');
+    }
+    const policySnap = read.layers.policySettings;
+    const policyCarrierDown = policySnap.outcome === 'unreadable' || policySnap.outcome === 'not-loaded';
+    if (policySnap.malformed || (policyCarrierDown && (read.managed === 'absent' || read.managed === 'in-effect'))) {
+        hostLog('debug', 'hooksWireCaps: policySettings could not be read — fail-closed (no hooks projected to the engine)');
+        return closedPlan('governance_unreadable');
+    }
+    const policyDoc = policySnap.doc;
+    const policy = policyDoc;
     let policyLayer;
     try {
         policyLayer = classifyLayer('policySettings', policyDoc);
     }
     catch (err) {
-        hostLog('debug', `hooksWireCaps: managed settings could not be read by the hooks reader — fail-closed (no hooks projected to the engine): ${String(err)}`);
-        return closedPlan(settings, 'governance_unreadable');
+        hostLog('debug', `hooksWireCaps: managed settings could not be read by the hooks reader — fail-closed (no hooks projected to the engine): ${faultText(err)}`);
+        return closedPlan('governance_unreadable');
     }
     if (policyLayer.row?.outcome === 'rejected') {
         settingsSalvage.push(policyLayer.row);
         hostLog('debug', 'hooksWireCaps: managed settings hooks rejected by the hooks reader — fail-closed (no hooks projected to the engine)');
-        return closedPlan(settings, 'governance_unreadable');
-    }
+        return closedPlan('governance_unreadable');
+    }
+    const docOnce = (source) => read.layers[source].doc;
+    const listDocOf = (source) => {
+        const snap = read.layers[source];
+        if (snap.malformed || snap.outcome === 'unreadable' || snap.outcome === 'not-loaded')
+            throw new LayerUnreadable(source);
+        return snap.doc;
+    };
+    const policyListDoc = () => {
+        if (managedReading.httpList === 'withhold')
+            throw new LayerUnreadable('policySettings');
+        return policyDoc;
+    };
     if (policy?.disableAllHooks === true) {
         hostLog('debug', 'hooksWireCaps: disableAllHooks (managed) — no hooks projected to the engine');
-        return closedPlan(settings, 'policy_disable_all');
+        return closedPlan('policy_disable_all');
     }
     const pluginOnlyHooks = hooksLockedToPluginOnly(policy?.strictPluginOnlyCustomization);
     if (pluginOnlyHooks) {
         hostLog('debug', 'hooksWireCaps: strictPluginOnlyCustomization locks the hooks surface (managed) — only policySettings hooks projected to the engine');
     }
-    const managedByPolicy = policy?.allowManagedHooksOnly === true || pluginOnlyHooks;
-    let mergedMemo;
-    const mergedDisable = () => (mergedMemo ??= nonManagedDisableAllHooks(settings));
+    const managedByPolicy = policy?.allowManagedHooksOnly === true || pluginOnlyHooks || managedReading.hooksRestriction === 'withhold';
+    if (managedReading.hooksRestriction === 'withhold') {
+        hostLog('debug', `hooksWireCaps: managed policy layer reported ${read.managed} — only policySettings hooks projected to the engine`);
+    }
+    const mergedDisable = () => mergedBooleanOf(read, 'disableAllHooks') === true || (read.current !== undefined && mergedBooleanOf(read.current, 'disableAllHooks') === true) || nonManagedLayerDown(read);
     const disabledByNonManaged = !managedByPolicy && mergedDisable();
     if (disabledByNonManaged) {
         hostLog('debug', 'hooksWireCaps: disableAllHooks (merged, non-managed) — only policySettings hooks projected to the engine');
     }
     const managedOnly = managedByPolicy || disabledByNonManaged;
+    let httpAdmitted;
+    let hookAdmitted;
+    try {
+        httpAdmitted = httpHookAdmittedSources(ALL_HOOK_SOURCES, read.trust);
+        hookAdmitted = admittedLayers(ALL_HOOK_SOURCES, read.trust, 'hooks');
+    }
+    catch (err) {
+        hostLog('debug', `http-hook-lists-admission-threw: ${faultText(err)}`);
+        return closedPlan('governance_unreadable');
+    }
     {
-        const sr = readSessionHooks(settings);
+        const sr = read.sessionHooks;
         sessionReader = sr.state;
         if (sr.sources !== undefined && !managedOnly) {
             const sources = sr.sources;
@@ -439,29 +436,25 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedL
             }
         }
     }
-    const read = readPluginHooks(settings, true);
-    let oldStartupBit;
-    let pluginDataThrew = false;
-    if (read.reading !== undefined) {
-        const reading = read.reading;
-        const bit = guardPluginTraversal(() => reading.suppressedByStartupMode === true);
-        if (bit === undefined)
-            pluginDataThrew = true;
-        else
-            oldStartupBit = bit;
-    }
-    const startupMode = startupModeWord(settings) ?? (oldStartupBit === true ? 'safe' : undefined);
+    const startupMode = read.startup === 'none' ? undefined : read.startup;
     if (startupMode === 'bare') {
         hostLog('debug', 'hooksWireCaps: bare mode reported by the host — only policySettings hooks projected to the engine (same as safe mode)');
     }
     else if (startupMode === 'safe') {
         hostLog('debug', 'hooksWireCaps: safe mode reported by the host — only policySettings hooks projected to the engine');
     }
-    const sources = managedOnly || startupMode !== undefined ? ['policySettings'] : ALL_HOOK_SOURCES;
+    const sources = managedOnly || startupMode !== undefined ? ['policySettings'] : hookAdmitted;
+    settingsSourcesNow = Object.freeze([...sources]);
+    const notAdmitted = ALL_HOOK_SOURCES.filter((s) => !hookAdmitted.includes(s) && read.layers[s].doc !== null);
+    if (sources === hookAdmitted)
+        settingsWithheldNow = Object.freeze(withheldRowsOf(notAdmitted, read.trust, read.layers));
+    if (sources !== hookAdmitted ? false : notAdmitted.length > 0) {
+        hostLog('debug', `hooksWireCaps: workspace trust reading ${read.trust} — hooks from ${notAdmitted.join(', ')} are not admitted (repository-controlled layers need an accepted workspace)`);
+    }
     const merged = {};
     const sourced = new Map();
     for (const source of sources) {
-        const layer = source === 'policySettings' ? policyLayer : layerOfSource(source);
+        const layer = source === 'policySettings' ? policyLayer : layerOfSource(source, docOnce);
         if (layer.row !== undefined)
             settingsSalvage.push(layer.row);
         const hooks = layer.hooks;
@@ -510,17 +503,25 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedL
         hostLog('debug', `hooksWireCaps: ${settingsStripped} settings hook entr${settingsStripped === 1 ? 'y' : 'ies'} carried a plugin key — ` +
             'stripped before sending (plugin context is only minted for entries from the plugin reader)');
     }
-    const wireOf = () => (Object.keys(merged).length > 0 ? merged : undefined);
-    if (read.reading === undefined)
-        return planOf(read.state, wireOf());
-    if (pluginDataThrew)
-        return planOf('failed', wireOf());
-    const reading = read.reading;
+    const wireOf = () => {
+        if (Object.keys(merged).length === 0)
+            return undefined;
+        const applied = wireHasHttpEntry(merged)
+            ? applyHttpHookPolicy(merged, readHttpHookPolicy(httpAdmitted, (layer) => (layer === 'policySettings' ? policyListDoc() : listDocOf(layer))))
+            : { wire: merged, rows: [] };
+        httpPolicyDrops.length = 0;
+        httpPolicyDrops.push(...applied.rows);
+        return applied.wire;
+    };
+    const pluginRead = read.plugins;
+    if (pluginRead.reading === undefined)
+        return planOf(pluginRead.state, wireOf());
+    const reading = pluginRead.reading;
     const occupied = occupancyOf(merged);
     const d = guardPluginTraversal(() => {
         const plugins = reading.plugins;
         const startup = startupMode !== undefined;
-        const managedOnlyPlugins = !startup && plugins.length > 0 && (policy?.allowManagedHooksOnly === true || mergedDisable());
+        const managedOnlyPlugins = !startup && plugins.length > 0 && (policy?.allowManagedHooksOnly === true || managedReading.hooksRestriction === 'withhold' || mergedDisable());
         return decidePluginHooks({
             plugins,
             exclusion: startup ? 'startup_mode' : undefined,
@@ -543,8 +544,6 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedL
 }
 export function __resetHooksWireCapsForTests() {
     __resetGoalStopHookForTests();
-    warnedNoMergedReader = new WeakSet();
-    warnedNoPluginReader = new WeakSet();
 }
 export function fleetHookFailureNoticeCapable(baseUrl) {
     return engineCapNestedTrue(baseUrl, 'fleet', 'hookFailureNotice');

package/dist/host.d.ts

@@ -2,16 +2,7 @@ import type { AdapterLogLevel, TimerHandle } from './seam.js';
 import type { WireHooksConfig } from './finalVerifyWire.js';
 import { type NotificationQueuePort } from './notifications.js';
 export type SettingsDocument = Record<string, unknown>;
-export interface SettingsPort {
-    getSettingsForSource(source: string): SettingsDocument | null;
-    shouldSkipHookDueToTrust(hook?: unknown): boolean;
-    mergedDisableAllHooks?(): boolean | undefined;
-    enabledPluginHooks?(): PluginHooksReading;
-    hooksStartupMode?(): HooksStartupMode | undefined;
-    managedPolicyReading?(): ManagedPolicyReading;
-    sessionHooks?(): SessionHooksReading;
-}
-export type ManagedPolicyState = 'absent' | 'in-effect' | 'unreadable';
+export type ManagedPolicyState = 'absent' | 'in-effect' | 'in-effect-pieces' | 'unreadable-covered' | 'unreadable-uncovered' | 'remote-unknown';
 export interface ManagedPolicyReading {
     readonly state: ManagedPolicyState;
 }
@@ -56,7 +47,6 @@ export interface SessionHooksReading {
 }
 export interface PluginHooksReading {
     readonly plugins: readonly PluginHookSource[];
-    readonly suppressedByStartupMode?: boolean;
 }
 export interface FsPort {
     getScratchpadDir(): string | undefined;
@@ -76,7 +66,6 @@ export interface HostPorts {
     probe?(channel: string, line: string): void;
     queue?: NotificationQueuePort | null;
     timers?: TimersPort;
-    settings?: SettingsPort;
     fs?: FsPort;
     session?: SessionPort;
 }
@@ -84,8 +73,6 @@ export declare function installHost(ports: HostPorts): () => void;
 export declare function installHostFor(sessionKey: string, ports: Omit<HostPorts, 'queue'>): () => void;
 export declare function hostLog(level: AdapterLogLevel, msg: string, data?: unknown): boolean;
 export declare function hostProbe(channel: string, line: string): void;
-export declare function hostSettings(): SettingsPort | undefined;
-export declare function hostSettingsFor(sessionKey: string): SettingsPort | undefined;
 export declare function hostFs(): FsPort | undefined;
 export declare function hostFsFor(sessionKey: string): FsPort | undefined;
 export declare function hostTimers(): TimersPort | undefined;

package/dist/host.js

@@ -36,8 +36,6 @@ export function installHostFor(sessionKey, ports) {
         slot.state.probe = ports.probe;
     if ('timers' in ports)
         slot.state.timers = ports.timers;
-    if ('settings' in ports)
-        slot.state.settings = ports.settings;
     if ('fs' in ports)
         slot.state.fs = ports.fs;
     if ('session' in ports)
@@ -63,12 +61,6 @@ export function hostLog(level, msg, data) {
 export function hostProbe(channel, line) {
     callDiagnosticPort(() => hostSlot(DEFAULT_SESSION_KEY).state.probe?.(channel, line));
 }
-export function hostSettings() {
-    return hostSettingsFor(DEFAULT_SESSION_KEY);
-}
-export function hostSettingsFor(sessionKey) {
-    return hostSlot(sessionKey).state.settings ?? miss(sessionKey, 'settings');
-}
 export function hostFs() {
     return hostFsFor(DEFAULT_SESSION_KEY);
 }

package/dist/hostCallbackGuard.d.ts

@@ -1,2 +1,3 @@
+export declare function faultText(e: {} | null | undefined): string;
 export declare function invokeHostCallbackIsolated(label: string, call: () => void): void;
 export declare function reasonOfThrownWithSink(e: unknown, sink: (log: string) => void): string;

package/dist/hostCallbackGuard.js

@@ -1,6 +1,6 @@
 import { hostLog } from './host.js';
 import { wireFailureTextsOf } from './wireFailureShape.js';
-function faultText(e) {
+export function faultText(e) {
     try {
         return String(e).slice(0, 160);
     }