@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/hitl/toolApprovalWire.js

@@ -11,6 +11,8 @@ import { readAllowRuleShadowFromWire, retiredAllowRuleShadowKeyPresent, RETIRED_
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
+import { CORE_ALLOW_ENTRY_INERT_REASONS } from '../generated/engineFactTables.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted } from '../displayUntrusted.js';
@@ -967,23 +969,24 @@ function usableProbeReason(raw) {
     return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
 }
 const PROBE_CAUSE_CODE_WORD = /^[a-z][a-z0-9_]{0,31}(?:\.[a-z][a-z0-9_]{0,31}){1,3}$/;
-export function askProbeReasonDetail(card) {
+export function askProbeReasonDetail(card, lang) {
     const prose = usableProbeReason(ownDataValue(card, 'probeReason'));
     const shown = prose === undefined ? '' : displayUntrusted(prose);
-    const sentence = probeCauseSentence(ownDataValue(card, 'probeCause'), shown !== '');
+    const sentence = probeCauseSentence(ownDataValue(card, 'probeCause'), shown !== '', lang);
     if (sentence === undefined)
         return shown === '' ? undefined : shown;
-    return shown === '' ? sentence : `${sentence} ${shown}`;
+    return shown === '' ? sentence : renderMessage(msg('approval.probe.proseJoin', { sentence, prose: shown }), lang);
 }
-function probeCauseSentence(cause, withProse) {
+function probeCauseSentence(cause, withProse, lang) {
     try {
         if (!isWireRecordCarrier(cause))
             return undefined;
         const code = ownDataValue(cause, 'code');
-        const head = withProse
-            ? 'An automatic check could not clear this call, so it is asking you'
-            : 'An automatic check could not clear this call, so it is asking you; the engine did not say the specific reason';
-        return typeof code === 'string' && PROBE_CAUSE_CODE_WORD.test(code) ? `${head} (check code: ${code}).` : `${head}.`;
+        const withCode = typeof code === 'string' && PROBE_CAUSE_CODE_WORD.test(code);
+        const key = withProse
+            ? withCode ? 'approval.probe.withProseCode' : 'approval.probe.withProse'
+            : withCode ? 'approval.probe.noProseCode' : 'approval.probe.noProse';
+        return renderMessage(withCode ? msg(key, { code }) : msg(key), lang);
     }
     catch {
         return undefined;
@@ -1041,6 +1044,21 @@ export function readApprovalBoundGrants(v) {
         return undefined;
     return Object.freeze({ skill, allowedTools, disallowedTools });
 }
+const READS_AS_NOTHING_HEAD = '<reads as nothing (';
+export function readBoundGrantEntry(entry) {
+    if (typeof entry !== 'string' || entry === '')
+        return undefined;
+    if (!entry.startsWith('<'))
+        return Object.freeze({ kind: 'rule' });
+    if (entry.startsWith(READS_AS_NOTHING_HEAD)) {
+        const close = entry.indexOf('): ', READS_AS_NOTHING_HEAD.length);
+        const word = close > 0 ? entry.slice(READS_AS_NOTHING_HEAD.length, close) : undefined;
+        if (word !== undefined && CORE_ALLOW_ENTRY_INERT_REASONS.includes(word)) {
+            return Object.freeze({ kind: 'reads_as_nothing', reason: word });
+        }
+    }
+    return Object.freeze({ kind: 'reads_as_nothing' });
+}
 const BOUND_GRANT_NOT_BINDABLE = 'not_bindable';
 const SERVER_CLASS_READ_CAP = 64;
 function readApprovalGrantBinding(carrier) {
@@ -1161,34 +1179,45 @@ export function readApprovalClassifierNoRuling(v) {
     return typeof w === 'string' && CAUSE_WORD.test(w) ? w : undefined;
 }
 const CLASSIFIER_NO_RULING_REASONS = Object.freeze({
-    error: 'could not run for this call (it failed)',
-    timeout: 'could not run for this call (it timed out)',
-    parse_error: 'answered for this call but gave no verdict it could use',
+    error: 'approval.classifier.noRulingError',
+    timeout: 'approval.classifier.noRulingTimeout',
+    parse_error: 'approval.classifier.noRulingParseError',
 });
 const _noRulingPin = [true, true];
 void _noRulingPin;
-export function classifierNoRulingDetail(word) {
+export function classifierNoRulingDetail(word, lang) {
     if (typeof word === 'string' && Object.hasOwn(CLASSIFIER_NO_RULING_REASONS, word)) {
-        return `The auto-mode classifier ${CLASSIFIER_NO_RULING_REASONS[word]}, so it is asking you instead.`;
+        return renderMessage(msg(CLASSIFIER_NO_RULING_REASONS[word]), lang);
     }
     if (typeof word === 'string' && CAUSE_WORD.test(word))
-        return `The auto-mode classifier did not rule on this call (reason: ${word}), so it is asking you instead.`;
-    return 'The auto-mode classifier did not rule on this call, so it is asking you instead.';
+        return renderMessage(msg('approval.classifier.noRulingOther', { reason: word }), lang);
+    return renderMessage(msg('approval.classifier.noRulingBare'), lang);
 }
-const entries = (n) => (n === 1 ? '1 tool entry' : `${String(n)} tool entries`);
-export function approvalBoundGrantsDetail(grants) {
+export function approvalBoundGrantsDetail(grants, lang) {
     const g = readApprovalBoundGrants({ boundGrants: grants });
     if (g === undefined)
         return undefined;
     if (g.skill === null)
-        return 'This call names no loaded skill, so approving it grants nothing beyond this call.';
-    const a = g.allowedTools.length;
-    const d = g.disallowedTools.length;
-    if (a === 0 && d === 0)
-        return 'Approving this activates the skill shown on the card; it lists no tools to run without asking and none to refuse.';
-    const allow = `${entries(a)} it lists ${a === 1 ? 'runs' : 'run'} without asking once it is active`;
-    const deny = `${entries(d)} ${d === 1 ? 'is' : 'are'} refused for the rest of this run`;
-    return `Approving this activates the skill shown on the card: ${allow}, and ${deny}.`;
+        return renderMessage(msg('approval.boundGrants.noSkill'), lang);
+    const isRule = (e) => readBoundGrantEntry(e)?.kind === 'rule';
+    const a = g.allowedTools.filter(isRule).length;
+    const d = g.disallowedTools.filter(isRule).length;
+    const allowNothing = g.allowedTools.length - a;
+    const denyNothing = g.disallowedTools.length - d;
+    if (denyNothing > 0) {
+        return renderMessage(denyNothing === 1 ? msg('approval.boundGrants.notActivated.one') : msg('approval.boundGrants.notActivated.other', { count: String(denyNothing) }), lang);
+    }
+    if (a === 0 && d === 0) {
+        if (allowNothing > 0)
+            return renderMessage(allowNothing === 1 ? msg('approval.boundGrants.listsNoToolsWithNothing.one') : msg('approval.boundGrants.listsNoToolsWithNothing.other', { count: String(allowNothing) }), lang);
+        return renderMessage(msg('approval.boundGrants.listsNoTools'), lang);
+    }
+    const allow = a === 1 ? msg('approval.boundGrants.allowPart.one') : msg('approval.boundGrants.allowPart.other', { count: a });
+    const deny = d === 1 ? msg('approval.boundGrants.denyPart.one') : msg('approval.boundGrants.denyPart.other', { count: d });
+    if (allowNothing > 0) {
+        return renderMessage(allowNothing === 1 ? msg('approval.boundGrants.activatesWithNothing.one', { allow, deny }) : msg('approval.boundGrants.activatesWithNothing.other', { allow, deny, count: String(allowNothing) }), lang);
+    }
+    return renderMessage(msg('approval.boundGrants.activates', { allow, deny }), lang);
 }
 const CALL_LEDGER_MAX_CALLS = 256;
 const CALL_LEDGER_MAX_ASKS_PER_CALL = 8;
@@ -1289,7 +1318,7 @@ function noteCallOutcome(slot, r) {
     const fateRank = { not_sent: 0, not_accepted: 1, unconfirmed: 2 };
     entry.answerFate = entry.answerFate !== undefined && fateRank[entry.answerFate] > fateRank[next] ? entry.answerFate : next;
 }
-export function approvalPriorCardsDetail(card) {
+export function approvalPriorCardsDetail(card, lang) {
     const prior = ownDataValue(card, 'priorCardsForCall');
     let isList = false;
     try {
@@ -1307,13 +1336,12 @@ export function approvalPriorCardsDetail(card) {
     for (let i = 0; i < length; i++)
         items.push(ownDataValue(prior, String(i)));
     const outcome = ownDataValue(items[length - 1], 'outcome');
-    const earlier = outcome === 'allowed' ? 'you already approved an earlier one' : outcome === 'denied' ? 'an earlier one was denied' : 'an earlier one was shown first';
+    const earlier = msg(outcome === 'allowed' ? 'approval.priorCard.earlier.allowed' : outcome === 'denied' ? 'approval.priorCard.earlier.denied' : 'approval.priorCard.earlier.shown');
     const fromRule = items.some((p) => ownDataValue(p, 'origin') === 'ask_rule');
     const thisFromRule = ownDataValue(card, 'origin') === 'ask_rule';
-    if (fromRule && !thisFromRule) {
-        return `This is a second approval for the same call: ${earlier}, which your ask rule asked for. This one is a separate check, not from your ask rule, and needs its own answer.`;
-    }
-    return `This is a second approval for the same call: ${earlier}. This one is a separate check and needs its own answer.`;
+    if (fromRule && !thisFromRule)
+        return renderMessage(msg('approval.priorCard.fromRule', { earlier }), lang);
+    return renderMessage(msg('approval.priorCard.plain', { earlier }), lang);
 }
 const PRIOR_ANSWER_PHRASE = Object.freeze({
     allow: 'Yes',
@@ -1710,10 +1738,9 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
     const receivedAtMs = Date.now();
     const approvalId = frame.approvalId;
     const entry = { frame, approvalId, identity: liveCardIdentityOf(approvalId, frame, run), respond, streamArgs, signal, lane, receivedAtMs };
-    return enterLiveCard(entry, 0);
+    return enterLiveCard(entry);
 }
-const LIVE_ENTRY_MAX_ROUNDS = 8;
-function enterLiveCard(e, round) {
+function enterLiveCard(e) {
     const { approvalId, signal } = e;
     const held = liveCardHoldOf(liveFrameCallKey(approvalId));
     if (held !== undefined)
@@ -1721,9 +1748,9 @@ function enterLiveCard(e, round) {
     const settled = settledLiveCardOutcome(approvalId);
     if (settled !== undefined)
         return Promise.resolve(settled);
-    const other = round < LIVE_ENTRY_MAX_ROUNDS ? approvalHoldFor(e.identity, (h) => h.lane === 'live') : undefined;
+    const other = approvalHoldFor(e.identity, (h) => h.lane === 'live');
     if (other !== undefined)
-        return joinOtherLaneHolder(e, other, round);
+        return joinOtherLaneHolder(e, other);
     return holdLiveCard(e.identity, signal, async (hold) => {
         const slot = {};
         const out = await presentToolApprovalFrameAndRespond(e.frame, approvalId, e.respond, e.streamArgs, signal, e.lane, hold, slot, e.receivedAtMs);
@@ -1731,7 +1758,7 @@ function enterLiveCard(e, round) {
         return out;
     });
 }
-async function joinOtherLaneHolder(e, other, round) {
+async function joinOtherLaneHolder(e, other) {
     const wait = await awaitApprovalHolder(other, e.signal, 'respond');
     if (wait.kind === 'settled') {
         noteHolderSettledApproval(e.approvalId, wait.how, wait.outcome);
@@ -1739,7 +1766,7 @@ async function joinOtherLaneHolder(e, other, round) {
     }
     if (wait.kind === 'left')
         return { kind: 'not_sent', lane: 'respond', cause: 'retracted', joinedInFlight: true };
-    return enterLiveCard(e, round + 1);
+    return enterLiveCard(e);
 }
 function liveCardIdentityOf(approvalId, frame, run) {
     const toolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;
@@ -1789,8 +1816,20 @@ export async function joinApprovalHolder(identity, signal) {
         return { kind: 'joined', outcome: { kind: 'not_sent', lane: 'decide', cause: 'retracted', joinedInFlight: true } };
     return { kind: 'free' };
 }
-export function claimApprovalCard(identity, signal) {
-    return claimApprovalCardFor(readApprovalHolderIdentity(identity), signal);
+function readApprovalCardClaimSignal(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, 'signal');
+        const x = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+        return typeof x === 'object' && x !== null ? x : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function claimApprovalCard(identity, options) {
+    return claimApprovalCardFor(readApprovalHolderIdentity(identity), readApprovalCardClaimSignal(options));
 }
 async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, streamArgs, signal, lane, hold, ledgerSlot, receivedAtMs) {
     const frameToolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;

package/dist/hooksWireCaps.js

@@ -1,7 +1,9 @@
 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 { createSettingsHookJudge, decidePluginHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, occupancyOf, } from './pluginHooksWire.js';
+import { hooksSalvageMaskOf, salvageSettingsHooksEntries, settingsHooksSalvageNotice } from './settingsHooksSalvage.js';
+import { createSettingsHookJudge, decidePluginHooks, decideSessionHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, hooksWirePlanShapeOf, occupancyOf, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, } from './goalStopHook.js';
@@ -99,15 +101,38 @@ function managedPolicyUnreadable(settings) {
         return true;
     }
 }
-function hooksOfSource(source) {
+const NO_LAYER = Object.freeze({ hooks: null, mask: undefined });
+function layerOfDoc(source, doc) {
     try {
-        const s = hostSettings()?.getSettingsForSource(source);
-        return s?.hooks && typeof s.hooks === 'object' && !Array.isArray(s.hooks) ? s.hooks : null;
+        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)}`);
+        return NO_LAYER;
+    }
+}
+function classifyLayer(source, doc) {
+    const salvage = salvageSettingsHooksEntries(doc);
+    const hooks = typeof doc === 'object' && doc !== null && !Array.isArray(doc) ? doc.hooks : undefined;
+    const original = typeof hooks === 'object' && hooks !== null && !Array.isArray(hooks) ? hooks : null;
+    if (salvage.outcome === 'loaded')
+        return { hooks: original, mask: undefined };
+    const notice = settingsHooksSalvageNotice(salvage, source, doc) ?? '';
+    const row = Object.freeze({ source, outcome: salvage.outcome, dropped: salvage.dropped, rejections: salvage.rejections, notice });
+    if (salvage.outcome === 'rejected')
+        return { hooks: null, mask: undefined, row };
+    return { hooks: original, mask: hooksSalvageMaskOf(salvage.dropped), row };
+}
+function layerOfSource(source) {
+    let doc;
+    try {
+        doc = hostSettings()?.getSettingsForSource(source);
     }
     catch (err) {
         hostLog('debug', `hooksWireCaps: ${source} settings read threw — treated as no hooks from this source: ${String(err)}`);
-        return null;
+        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() — ' +
@@ -143,32 +168,70 @@ function readPluginHooks(settings, warnIfAbsent) {
     }
     return { state: 'absent' };
 }
-function usageError(tail) {
-    return new TypeError(`hooksForWire: pass { plan } with the plan returned by hooksWirePlan() for this turn — ${tail}`);
+function readSessionHooks(settings) {
+    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' };
+    }
+    catch (err) {
+        hostLog('debug', `hooksWireCaps: sessionHooks() threw — no session hooks judged this turn: ${String(err)}`);
+        return { state: 'failed' };
+    }
+}
+function suppressedLocallyOf(o) {
+    let raw;
+    try {
+        raw = o.suppressedLocally;
+    }
+    catch {
+        hostLog('debug', 'hooksWirePlan: suppressedLocally threw while being read — treated as absent (no plugin suppressed locally)');
+        return undefined;
+    }
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw) || !raw.every((x) => typeof x === 'string')) {
+        hostLog('debug', 'hooksWirePlan: suppressedLocally is not an array of plugin ids — treated as absent (no plugin suppressed locally)');
+        return undefined;
+    }
+    return new Set(raw);
+}
+function usageError(sentence) {
+    return new TypeError(renderMessage(sentence));
 }
 function hostValueShape(v) {
     try {
         if (v === undefined)
-            return 'nothing';
+            return msg('config.hooks.valueShape.nothing');
         if (v === null)
-            return 'null';
+            return msg('config.hooks.valueShape.null');
         if (Array.isArray(v))
-            return 'an array';
-        return typeof v === 'object' ? 'an object' : `a ${typeof v}`;
+            return msg('config.hooks.valueShape.array');
+        return typeof v === 'object' ? msg('config.hooks.valueShape.object') : msg('config.hooks.valueShape.typeof', { type: typeof v });
     }
     catch {
-        return 'unreadable';
+        return msg('config.hooks.valueShape.unreadable');
     }
 }
 export function hooksForWire(opts) {
     if (typeof opts !== 'object' || opts === null)
-        throw usageError(`got ${hostValueShape(opts)}.`);
+        throw usageError(msg('config.hooks.forWire.gotShape', { shape: hostValueShape(opts) }));
     let given;
     try {
         given = opts.plan;
     }
     catch {
-        throw usageError(`reading opts.plan threw.`);
+        throw usageError(msg('config.hooks.forWire.readPlanThrew'));
     }
     const shape = planShapeOf(given);
     if (shape === 'plan') {
@@ -176,46 +239,16 @@ export function hooksForWire(opts) {
             return given.wire;
         }
         catch {
-            throw usageError(`reading the plan's wire threw.`);
+            throw usageError(msg('config.hooks.forWire.readWireThrew'));
         }
     }
     if (shape === 'threw')
-        throw usageError(`opts.plan could not be read as a plan.`);
+        throw usageError(msg('config.hooks.forWire.planUnreadable'));
     if (given === undefined && planShapeOf(opts) === 'plan')
-        throw usageError(`the plan itself was passed; wrap it as { plan }.`);
-    throw usageError(`opts.plan is ${given === undefined ? 'missing' : `not such a plan (got ${hostValueShape(given)})`}.`);
+        throw usageError(msg('config.hooks.forWire.planPassedBare'));
+    throw usageError(given === undefined ? msg('config.hooks.forWire.planMissing') : msg('config.hooks.forWire.planNotPlan', { shape: hostValueShape(given) }));
 }
-function planShapeOf(v) {
-    try {
-        if (typeof v !== 'object' || v === null || Array.isArray(v))
-            return 'not';
-        const o = v;
-        for (const k of PLAN_KEYS)
-            if (!Object.hasOwn(o, k) && k !== 'settingsVerdicts' && k !== 'settingsExcluded')
-                return 'not';
-        const reader = o.pluginReader;
-        const engineFacts = o.engine;
-        const wire = o.wire;
-        const arrayOrAbsent = (k) => !Object.hasOwn(o, k) || Array.isArray(o[k]);
-        return Array.isArray(o.verdicts) &&
-            Array.isArray(o.excluded) &&
-            Array.isArray(o.settingsDropped) &&
-            arrayOrAbsent('settingsVerdicts') &&
-            arrayOrAbsent('settingsExcluded') &&
-            (reader === 'present' || reader === 'absent' || reader === 'failed') &&
-            typeof engineFacts === 'object' &&
-            engineFacts !== null &&
-            (wire === undefined || (typeof wire === 'object' && wire !== null && !Array.isArray(wire)))
-            ? 'plan'
-            : 'not';
-    }
-    catch {
-        return 'threw';
-    }
-}
-const PLAN_KEYS = ['engine', 'pluginReader', 'verdicts', 'excluded', 'settingsDropped', 'settingsVerdicts', 'settingsExcluded', 'wire'];
-const _planKeysPin = [true, true];
-void _planKeysPin;
+const planShapeOf = hooksWirePlanShapeOf;
 export function hooksWirePlan(opts = {}) {
     const o = opts ?? {};
     const owned = o.engineOwnedByThisShell;
@@ -241,7 +274,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));
+    return buildHooksWirePlan(engine, shellRuns, promptAuthoredByUserOf(o), suppressedLocallyOf(o));
 }
 function taskHooksCapability(baseUrl) {
     const v = engineCapValue(baseUrl, 'taskSettings');
@@ -292,14 +325,34 @@ function promptAuthoredByUserOf(o) {
     }
     return true;
 }
-function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
+function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser, suppressedLocally) {
     const settingsDropped = [];
     const settingsVerdicts = [];
     const settingsExcluded = [];
+    const settingsSalvage = [];
+    let sessionVerdicts = [];
+    let sessionReader = 'absent';
+    let closedBy = null;
     const judge = createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser);
     let settingsStripped = 0;
-    const planOf = (pluginReader, wire, verdicts = [], excluded = []) => ({ engine, pluginReader, verdicts, excluded, settingsDropped, settingsVerdicts, settingsExcluded, wire });
+    const planOf = (pluginReader, wire, verdicts = [], excluded = [], moduleVerdicts = []) => ({
+        engine,
+        pluginReader,
+        verdicts,
+        excluded,
+        settingsDropped,
+        settingsVerdicts,
+        settingsExcluded,
+        settingsSalvage,
+        moduleVerdicts,
+        sessionVerdicts,
+        sessionReader,
+        closedBy,
+        wire,
+    });
     const closedPlan = (settings, reason) => {
+        closedBy = reason;
+        sessionReader = readSessionHooks(settings).state;
         const read = readPluginHooks(settings, false);
         if (read.reading === undefined)
             return planOf(read.state, undefined);
@@ -333,13 +386,28 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
     if (managedPolicyUnreadable(settings))
         return closedPlan(settings, 'governance_unreadable');
     let policy = null;
+    let policyDoc;
     try {
-        policy = settings.getSettingsForSource('policySettings');
+        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');
     }
+    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');
+    }
+    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');
+    }
     if (policy?.disableAllHooks === true) {
         hostLog('debug', 'hooksWireCaps: disableAllHooks (managed) — no hooks projected to the engine');
         return closedPlan(settings, 'policy_disable_all');
@@ -356,6 +424,21 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
         hostLog('debug', 'hooksWireCaps: disableAllHooks (merged, non-managed) — only policySettings hooks projected to the engine');
     }
     const managedOnly = managedByPolicy || disabledByNonManaged;
+    {
+        const sr = readSessionHooks(settings);
+        sessionReader = sr.state;
+        if (sr.sources !== undefined && !managedOnly) {
+            const sources = sr.sources;
+            const ds = guardPluginTraversal(() => decideSessionHooks({ sources, engine, shellRuns, promptAuthoredByUser }));
+            if (ds === undefined)
+                sessionReader = 'failed';
+            else {
+                sessionVerdicts = ds.verdicts;
+                if (ds.unreadable > 0)
+                    hostLog('debug', `hooksWireCaps: ${ds.unreadable} session hook source(s) or group(s) unreadable — skipped`);
+            }
+        }
+    }
     const read = readPluginHooks(settings, true);
     let oldStartupBit;
     let pluginDataThrew = false;
@@ -378,13 +461,18 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
     const merged = {};
     const sourced = new Map();
     for (const source of sources) {
-        const hooks = hooksOfSource(source);
+        const layer = source === 'policySettings' ? policyLayer : layerOfSource(source);
+        if (layer.row !== undefined)
+            settingsSalvage.push(layer.row);
+        const hooks = layer.hooks;
         if (!hooks)
             continue;
         for (const [event, groups] of Object.entries(hooks)) {
+            if (layer.mask !== undefined && layer.mask.eventDropped(event))
+                continue;
             if (!Array.isArray(groups) || groups.length === 0)
                 continue;
-            const kept = filterSettingsHookGroups(source, event, groups, engine.pluginHooksCapable === true, (type) => shellRuns(event, type), judge);
+            const kept = filterSettingsHookGroups(source, event, groups, engine.pluginHooksCapable === true, (type) => shellRuns(event, type), judge, layer.mask);
             settingsDropped.push(...kept.drops);
             settingsVerdicts.push(...kept.verdicts);
             settingsExcluded.push(...kept.excluded);
@@ -441,6 +529,7 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
             shellRuns,
             promptAuthoredByUser,
             occupied,
+            ...(suppressedLocally !== undefined ? { suppressedLocally } : {}),
         });
     });
     if (d === undefined)
@@ -450,7 +539,7 @@ function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
     }
     for (const [event, groups] of d.projected)
         merged[event] = [...(merged[event] ?? []), ...groups];
-    return planOf('present', wireOf(), d.verdicts, d.excluded);
+    return planOf('present', wireOf(), d.verdicts, d.excluded, d.modules);
 }
 export function __resetHooksWireCapsForTests() {
     __resetGoalStopHookForTests();

package/dist/host.d.ts

@@ -9,6 +9,7 @@ export interface SettingsPort {
     enabledPluginHooks?(): PluginHooksReading;
     hooksStartupMode?(): HooksStartupMode | undefined;
     managedPolicyReading?(): ManagedPolicyReading;
+    sessionHooks?(): SessionHooksReading;
 }
 export type ManagedPolicyState = 'absent' | 'in-effect' | 'unreadable';
 export interface ManagedPolicyReading {
@@ -32,6 +33,26 @@ export interface PluginHookSource {
     readonly managed: boolean;
     readonly options?: Readonly<Record<string, PluginHookOption>>;
     readonly hooks: WireHooksConfig;
+    readonly hooksModule?: boolean;
+}
+export type SessionHookOrigin = 'skill' | 'agent' | 'sdk_host';
+export interface SessionHookSource {
+    readonly origin: SessionHookOrigin;
+    readonly name: string;
+    readonly hooks: WireHooksConfig | {
+        readonly [event: string]: readonly {
+            readonly matcher?: string;
+            readonly hooks: readonly (NonNullable<WireHooksConfig[string]>[number]['hooks'][number] | SessionLocalHook)[];
+        }[] | undefined;
+    };
+}
+export interface SessionLocalHook {
+    readonly type: 'callback' | 'function';
+    readonly callback?: (...args: never[]) => void;
+    readonly timeout?: number;
+}
+export interface SessionHooksReading {
+    readonly sources: readonly SessionHookSource[];
 }
 export interface PluginHooksReading {
     readonly plugins: readonly PluginHookSource[];

package/dist/hostTurnSettings.d.ts

@@ -0,0 +1,71 @@
+import type { WireHooksConfig } from './finalVerifyWire.js';
+import type { SettingsDocument } from './host.js';
+import { type HookSettingsSource, type HooksWirePlan } from './pluginHooksWire.js';
+export declare const HOST_SUPPLIED_KEYS: readonly ["settings.hooks", "settings.resolved", "settings.webSearch", "settings.outputStyle"];
+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"];
+export type HostSettingCause = (typeof HOST_SETTING_CAUSES)[number];
+export declare const HOST_SETTING_DISPOSITIONS: readonly ["carry", "carry_partial", "withhold_notice", "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';
+export interface HostSettingRow {
+    readonly key: HostSuppliedKey;
+    readonly cause: HostSettingCause;
+    readonly disposition: HostSettingDisposition;
+    readonly layers?: readonly HookSettingsSource[];
+}
+export interface HostSettingNotice {
+    readonly id: HostSettingNoticeId;
+    readonly plane: HostSettingPlane;
+    readonly text: string;
+}
+export type HostTurnVerdict = {
+    readonly kind: 'send';
+} | {
+    readonly kind: 'refuse';
+    readonly notice: HostSettingNotice;
+};
+export interface HostTurnSettingsSources {
+    readonly hooks: {
+        readonly plan: HooksWirePlan;
+    } | 'none';
+    readonly resolved: {
+        readonly snapshot: SettingsDocument;
+    } | 'none';
+    readonly webSearch: {
+        readonly settings: SettingsDocument;
+    } | 'none';
+    readonly outputStyle: {
+        readonly name: string;
+    } | 'none';
+}
+export interface HostTurnSettingsInput {
+    readonly sources: HostTurnSettingsSources;
+}
+export interface HostSettingsCarried {
+    readonly hooks?: WireHooksConfig;
+    readonly resolved?: SettingsDocument;
+    readonly webSearch?: SettingsDocument;
+    readonly outputStyle?: string;
+}
+declare const hostTurnSettingsBrand: unique symbol;
+export interface HostTurnSettings {
+    readonly [hostTurnSettingsBrand]: true;
+    readonly verdict: HostTurnVerdict;
+    readonly rows: readonly HostSettingRow[];
+    readonly notices: readonly HostSettingNotice[];
+    readonly hooks: HooksWirePlan | undefined;
+    readonly carried: HostSettingsCarried;
+}
+export declare function rethrowHostResolvedDeferred(product: HostTurnSettings): void;
+export type HostResolvedMaterializer = (snapshot: SettingsDocument) => SettingsDocument;
+export declare function buildHostTurnSettings(input: HostTurnSettingsInput, materialize: HostResolvedMaterializer): HostTurnSettings;
+export declare function hostSettingsSelfCheck(product: HostTurnSettings): readonly HostSuppliedKey[];
+export declare class HostSettingsRefused extends Error {
+    readonly notice: HostSettingNotice;
+    constructor(n: HostSettingNotice);
+}
+export declare function hostTurnSettingsOf(v: unknown, depth?: 'shape' | 'full'): HostTurnSettings | undefined;
+export declare const UNWIRED_HOST_TURN_SETTINGS: HostTurnSettings;
+export {};