@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/hitl/toolApprovalWire.js

@@ -3,10 +3,11 @@ import { askParkRowArm } from './askParkRowRouting.js';
 import { parkGateArmOf } from './frameRouter.js';
 import { seatSessionRowOf } from './standingRows.js';
 import { hostLog } from '../host.js';
-import { guardedRead, readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
+import { appendOwnElement, guardedRead, readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
+import { ownReadingSlot } from '../engineWireFor.js';
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPair } from './askClassPair.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
-import { approvalWindowKeysOf, readRequiresRealApproval } from './approvalCardReading.js';
+import { approvalWindowKeysOf, readApprovalCardWord, readRequiresRealApproval } from './approvalCardReading.js';
 import { readAllowRuleShadowFromWire, retiredAllowRuleShadowKeyPresent, RETIRED_SHADOW_EVIDENCE_LABEL } from './allowRuleShadow.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
@@ -18,16 +19,17 @@ import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { frameBindingOf } from '../frameBinding.js';
 import { carriesAttributionKey, deliverWithAttributionLadder } from './attributionLadder.js';
+import { deliverApprovalDecision, newSendTally } from './approvalDelivery.js';
 import { approvalDecisionHolds, approvalHoldFor, awaitApprovalHolder, claimApprovalCardFor, enterLiveRespondPhase, holdLiveCard, joinLiveCard, liveCardHoldOf, clearSettledApprovals, noteHolderSettledApproval, settledApprovalOf, settledForDurableLane, settledLiveCardOutcome } from './approvalHolds.js';
-import { joinedResolution, resolutionOfDecisionFailure } from './approvalResolution.js';
+import { directFailureVerdictOf, directSafetyStopOf, joinedResolution, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { parkRowDeadlineState } from './parkExpiryJudgements.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
-import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, TOOL_APPROVAL_CARD_WORDS, } from '@sema-agent/sdk';
+import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, } from '@sema-agent/sdk';
 export function toolNameIsFsWrite(name) {
     const n = name.replace(/[\s_-]+/g, '').toLowerCase();
     return (n === 'write' || n === 'filewrite' || n === 'edit' || n === 'fileedit' || n === 'multiedit' || n === 'notebookedit');
@@ -78,7 +80,7 @@ export function readApprovalDenySettledBy(decision) {
     catch {
         return undefined;
     }
-    if (d === undefined || !('value' in d))
+    if (d === undefined || !Object.hasOwn(d, 'value'))
         return undefined;
     const v = d.value;
     return typeof v === 'string' && APPROVAL_DENY_SETTLED_BY_WORDS.includes(v)
@@ -417,6 +419,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 }
                 return { kind: 'unsettled', ...at, cause: 'interrupted' };
             case 'allow':
+                let rememberStop;
                 try {
                     let rememberRefused = false;
                     const approveBody = answerPayloadFor(card, 'decide');
@@ -434,6 +437,11 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                         catch (e) {
                             if (rememberRefusalOf(e) === undefined)
                                 throw e;
+                            const verdict = directFailureVerdictOf(e, directSafetyStopOf(e));
+                            if (verdict.yields) {
+                                rememberStop = ownReadingSlot(verdict, 'directStop');
+                                throw e;
+                            }
                             rememberRefused = true;
                             logAfterDecided(`liveToolApprovalWire: decide(approve+remember) refused the remember part (${String(e)}) — falling back to plain approve`);
                         }
@@ -450,15 +458,17 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     return { kind: 'decided', ...at, decision: 'allow', ...(receipt !== undefined ? { receipt } : {}) };
                 }
                 catch (e) {
+                    const directStop = rememberStop !== undefined && rememberStop.thrown === e ? rememberStop : directSafetyStopOf(e);
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `liveToolApprovalWire: decide(approve) failed: ${failureTexts.log}`);
-                    return resolutionOfDecisionFailure(e, { lane: 'decide', route: 'approval_decide', gatedCallId, detail: `decide(approve) failed: ${failureTexts.reason}${decideFailureNote(e, 'approve')}` });
+                    return resolutionOfDecisionFailure(e, { lane: 'decide', route: 'approval_decide', gatedCallId, detail: `decide(approve) failed: ${failureTexts.reason}${decideFailureNote(e, 'approve')}`, ...(directStop !== undefined ? { directStop } : {}) });
                 }
             case 'deny': {
                 const denySettledByForWire = readApprovalDenySettledBy(card);
                 const attributionKeys = decisionAttributionKeyOf(decidedByReading, denySettledByForWire);
                 const denyReasonSnapshot = ((r) => (typeof r === 'string' ? r : undefined))(card.reason);
                 let lastSendCarriedAttribution = false;
+                let ladderSafetyStop;
                 try {
                     const denyPayload = { decision: 'deny', reason: answerPayloadFor({ kind: 'deny', ...(denyReasonSnapshot !== undefined ? { reason: denyReasonSnapshot } : {}) }, 'decide').reason };
                     const denyBody = { ...denyPayload, ...attributionKeys };
@@ -479,10 +489,11 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                                     : `liveToolApprovalWire: decide(deny) for task ${taskId} was refused again because the settlement note is not part of ` +
                                         'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
                                         '(still before the approval was judged)');
-                        });
+                        }, { kind: 'direct', stopOf: directSafetyStopOf });
                     }
                     finally {
                         lastSendCarriedAttribution = ladder.lastCarried;
+                        ladderSafetyStop = ladder.safetyStop;
                     }
                     const attributionDropped = ladder.dropped;
                     const attributionRenamed = ladder.renamed;
@@ -497,6 +508,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     };
                 }
                 catch (e) {
+                    const directStop = ladderSafetyStop !== undefined && ladderSafetyStop.thrown === e ? ladderSafetyStop : directSafetyStopOf(e);
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `liveToolApprovalWire: decide(deny) failed: ${failureTexts.log}`);
                     return resolutionOfDecisionFailure(e, {
@@ -505,6 +517,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                         gatedCallId,
                         detail: `decide(deny) failed: ${failureTexts.reason}${decideFailureNote(e, 'deny')}`,
                         attributionCarried: lastSendCarriedAttribution,
+                        ...(directStop !== undefined ? { directStop } : {}),
                     });
                 }
             }
@@ -588,20 +601,7 @@ export function readApprovalMandate(v) {
     const raw = v.mandate;
     return isApprovalMandateWord(raw) ? raw : undefined;
 }
-const APPROVAL_CARD_WORD_SET = new Set(TOOL_APPROVAL_CARD_WORDS);
-export function readApprovalCardWord(carrier) {
-    try {
-        if (typeof carrier !== 'object' || carrier === null)
-            return undefined;
-        const d = Object.getOwnPropertyDescriptor(carrier, 'approvalCard');
-        if (d === undefined || !('value' in d))
-            return undefined;
-        return APPROVAL_CARD_WORD_SET.has(d.value) ? d.value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
+export { readApprovalCardWord };
 export function toolPermissionRequestAskBits(card, requestId) {
     if (typeof card !== 'object' || card === null)
         return {};
@@ -958,7 +958,7 @@ function ownDataValue(v, key) {
         return undefined;
     try {
         const d = Object.getOwnPropertyDescriptor(v, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;
@@ -974,9 +974,9 @@ function ownStringList(v) {
         const out = [];
         for (let i = 0; i < length; i++) {
             const d = Object.getOwnPropertyDescriptor(v, i);
-            if (d === undefined || !('value' in d) || typeof d.value !== 'string' || d.value === '')
+            if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string' || d.value === '')
                 return undefined;
-            out.push(d.value);
+            appendOwnElement(out, d.value);
         }
         return v.length === length ? Object.freeze(out) : undefined;
     }
@@ -1085,18 +1085,8 @@ const UNREADABLE_EVIDENCE_KEYS = Object.freeze({
     ]),
     generic: Object.freeze([['ruleOffersAbsence', 'ruleOffersAbsence'], ['askClass', 'askClass'], ['classes', 'classes']]),
 });
-function carrierHas(carrier, key) {
-    if (typeof carrier !== 'object' || carrier === null)
-        return false;
-    try {
-        return key in carrier;
-    }
-    catch {
-        return true;
-    }
-}
 function v1RiskUnreadable(card) {
-    if (!carrierHas(card, 'risk'))
+    if (slotPresenceOf(card, 'risk') === 'absent')
         return false;
     try {
         const risk = card.risk;
@@ -1109,12 +1099,12 @@ function v1RiskUnreadable(card) {
 function withUnreadableEvidence(carrier, leg, req, reported = []) {
     const keys = new Set(reported);
     for (const [from, to] of UNREADABLE_EVIDENCE_KEYS[leg]) {
-        if (carrierHas(carrier, from) && !Object.hasOwn(req, to))
+        if (slotPresenceOf(carrier, from) !== 'absent' && !Object.hasOwn(req, to))
             keys.add(from);
     }
     if (leg === 'row') {
         const rd = ownDataValue(carrier, 'riskDescriptor');
-        if (carrierHas(rd, 'allowRuleShadowed') && !Object.hasOwn(req, 'allowRuleShadow'))
+        if (typeof rd === 'object' && rd !== null && slotPresenceOf(rd, 'allowRuleShadowed') !== 'absent' && !Object.hasOwn(req, 'allowRuleShadow'))
             keys.add('riskDescriptor.allowRuleShadowed');
     }
     if (leg !== 'generic' && !Object.hasOwn(req, 'allowRuleShadow')) {
@@ -1845,6 +1835,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
     const attributionKeys = decision === 'deny' ? decisionAttributionKeyOf(decidedByReading, denySettledByForWire) : {};
     const sentAttributionKey = carriesAttributionKey(attributionKeys);
     let lastSendCarriedAttribution = sentAttributionKey;
+    let deliveryFailure;
     const denyReasonSnapshot = denyReasonRead;
     if (card.kind === 'failed') {
         hostLog('debug', `liveToolApprovalWire: approval card unavailable (${card.reason}) — fail-closed deny for ${approvalId}`);
@@ -1926,8 +1917,8 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
                 ruleArmDroppedForCheck = 'text_not_offered';
             }
         }
+        const signalPreAborted = signal !== undefined && signal.aborted;
         const respondOpts = {
-            ...(signal && !signal.aborted ? { signal } : {}),
             ...(basePayload?.updatedInput !== undefined ? { updatedInput: basePayload.updatedInput } : {}),
             ...(persistRule !== undefined ? { persistRule } : {}),
             ...(persistRuleEdited !== undefined ? { persistRuleEdited } : {}),
@@ -1940,19 +1931,36 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         if (basePayload !== undefined)
             emitAnswerCommitted(liveFrameCallKey(approvalId), 'respond', answerSnapshot, basePayload);
         try {
-            raw = await deliverWithAttributionLadder(respondOpts, (o) => respond(approvalId, decision, o), signal, ladder, (step) => {
-                hostLog('debug', step === 'renamed'
-                    ? `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note was sent under a name ` +
-                        'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
-                        '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
-                    : step === 'dropped'
-                        ? `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note is not part of ` +
-                            'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
+            const delivery = await deliverApprovalDecision({
+                approvalId,
+                body: respondOpts,
+                send: (o, sig) => respond(approvalId, decision, !signalPreAborted && sig !== undefined ? { ...o, signal: sig } : o),
+                signal,
+                tally: newSendTally(),
+                ladder,
+                onLadderStep: (step) => {
+                    hostLog('debug', step === 'renamed'
+                        ? `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note was sent under a name ` +
+                            'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
                             '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
-                        : `liveToolApprovalWire: respond(deny) for ${approvalId} was refused again because the settlement note is not part of ` +
-                            'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
-                            '(still before the approval was judged)');
+                        : step === 'dropped'
+                            ? `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note is not part of ` +
+                                'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
+                                '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)'
+                            : `liveToolApprovalWire: respond(deny) for ${approvalId} was refused again because the settlement note is not part of ` +
+                                'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
+                                '(still before the approval was judged)');
+                },
+                parkingOf: (body) => {
+                    const p = readToolApprovalRespondParking(body);
+                    return p?.kind === 'parking' ? p.view : undefined;
+                },
             });
+            if (delivery.kind === 'thrown') {
+                deliveryFailure = delivery;
+                throw delivery.error;
+            }
+            raw = delivery.raw;
         }
         finally {
             lastSendCarriedAttribution = ladder.lastCarried;
@@ -1963,9 +1971,11 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         if (parkingBody !== undefined) {
             const parking = parkingBody.kind === 'parking' && parkingBody.view.approvalId === approvalId ? parkingBody.view : undefined;
             if (parking !== undefined) {
-                hostLog('debug', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered 202 parking_in_progress${parking.retryAfterMs !== undefined ? ` (retryAfterMs=${parking.retryAfterMs})` : ''} — ` +
-                    `the answer did NOT take effect${parking.decidePath !== undefined ? ' (the engine pointed at a decide path for the parked card)' : ''}; not re-sent, not reported as decided; the user is told to answer again on the parked card`);
-                surfaceApprovalParking(parking.retryAfterMs);
+                const hint = ownReadingSlot(parking, 'retryAfterMs');
+                const decidePath = ownReadingSlot(parking, 'decidePath');
+                hostLog('debug', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered 202 parking_in_progress${hint !== undefined ? ` (retryAfterMs=${hint})` : ''} — ` +
+                    `the answer did NOT take effect${decidePath !== undefined ? ' (the engine pointed at a decide path for the parked card)' : ''}; not reported as decided (the one invited re-send, if any, has already been made); the user is told to answer again on the parked card`);
+                surfaceApprovalParking(hint);
                 return { kind: 'unsettled', lane: 'respond', cause: 'parking_in_progress', parking };
             }
             hostLog('error', `liveToolApprovalWire: 202 parking body for ${approvalId} is ${parkingBody.kind === 'parking' ? `for another approval (${parkingBody.view.approvalId})` : 'unreadable (approvalId is not usable)'} — ` +
@@ -2065,7 +2075,15 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         return { kind: 'decided', lane: 'respond', decision, ...(ack !== undefined ? { ack } : {}), ...(deny !== undefined ? { deny } : {}) };
     }
     catch (e) {
-        const r = resolutionOfDecisionFailure(e, { lane: 'respond', route: 'live_respond', attributionCarried: lastSendCarriedAttribution });
+        const fromDelivery = deliveryFailure !== undefined && deliveryFailure.error === e ? deliveryFailure : undefined;
+        const r = resolutionOfDecisionFailure(e, {
+            lane: 'respond',
+            route: 'live_respond',
+            attributionCarried: lastSendCarriedAttribution,
+            ...(fromDelivery?.transportExhausted === true ? { transportExhausted: true } : {}),
+            ...(fromDelivery?.afterRetry === true ? { afterRetry: true } : {}),
+            ...(fromDelivery !== undefined ? { delivered: fromDelivery.reading } : {}),
+        });
         const refusal = r.kind === 'unsettled' ? r.refusal : undefined;
         hostLog('debug', `liveToolApprovalWire: respond(${decision}) failed for ${approvalId} ` +
             `(status=${refusal?.status ?? 'none'} errorCode=${logSafeErrorCode(refusal?.errorCode)} ` +

package/dist/hookMatcherVerdict.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type HookMatcherUnjudgedReason = 'event_out_of_scope' | 'not_a_string' | 'oversize' | 'pattern_unsupported' | 'over_budget';
 export type HookMatcherRefusedReason = 'alias_without_canonical' | 'invalid_regex';
 export type HookMatcherVerdict = {
@@ -24,3 +25,4 @@ export type HookMatcherVerdict = {
     readonly reason: HookMatcherUnjudgedReason;
 };
 export declare function hookMatcherVerdict(event: string, matcher: unknown): HookMatcherVerdict;
+export declare function hookMatcherUnjudgedWhy(reason: HookMatcherUnjudgedReason | string, lang?: UiLanguage): string;

package/dist/hookMatcherVerdict.js

@@ -1,3 +1,4 @@
+import { msg, renderMessage } from './i18n/translate.js';
 import { HOOK_TOOL_ALIASES } from './hookToolAliases.js';
 import { SETTINGS_TOOL_NAME_MATCHER_EVENTS } from './generated/settingsSchemaTables.js';
 import { SETTINGS_HOOK_MATCHER_FORM, SETTINGS_HOOK_MATCHER_SELECTS } from './generated/settingsSchemaFns.js';
@@ -231,3 +232,14 @@ export function hookMatcherVerdict(event, matcher) {
     }
     return Object.freeze({ kind: 'accepted', reading, aliases: Object.freeze(selected.map((p) => Object.freeze({ ...p }))) });
 }
+const UNJUDGED_WHY_KEY = {
+    event_out_of_scope: 'config.hooks.matcher.unjudged.eventOutOfScope',
+    not_a_string: 'config.hooks.matcher.unjudged.notAString',
+    oversize: 'config.hooks.matcher.unjudged.oversize',
+    pattern_unsupported: 'config.hooks.matcher.unjudged.patternUnsupported',
+    over_budget: 'config.hooks.matcher.unjudged.overBudget',
+};
+export function hookMatcherUnjudgedWhy(reason, lang) {
+    const key = typeof reason === 'string' && Object.hasOwn(UNJUDGED_WHY_KEY, reason) ? UNJUDGED_WHY_KEY[reason] : 'config.hooks.matcher.unjudged.unknown';
+    return renderMessage(msg(key), lang);
+}

package/dist/hooksCompactTransition.d.ts

@@ -0,0 +1,19 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const COMPACT_LATCH_STATES: readonly ["armed", "fired", "none"];
+export type CompactLatchState = (typeof COMPACT_LATCH_STATES)[number];
+export declare const COMPACT_SUMMARY_LEGS: readonly ["engine", "local_fallback", "local_fallback_unavailable", "none"];
+export type CompactSummaryLeg = (typeof COMPACT_SUMMARY_LEGS)[number];
+export type CompactHookExecutor = 'engine' | 'shell' | 'none';
+export type CompactHookDisclosure = 'engine_outcome_unknown' | 'neither_ran';
+export interface CompactHookTransitionInput {
+    readonly latch: CompactLatchState;
+    readonly leg: CompactSummaryLeg;
+}
+export interface CompactHookTransition {
+    readonly executor: CompactHookExecutor;
+    readonly revokeEngineRun: boolean;
+    readonly shellRunsHook: boolean;
+    readonly disclosure?: CompactHookDisclosure;
+}
+export declare function compactHookTransition(input: CompactHookTransitionInput): CompactHookTransition;
+export declare function compactHookDisclosureSentence(disclosure: CompactHookDisclosure, lang?: UiLanguage): string;

package/dist/hooksCompactTransition.js

@@ -0,0 +1,41 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { readOwnDataValue } from './ownKey.js';
+export const COMPACT_LATCH_STATES = Object.freeze(['armed', 'fired', 'none']);
+export const COMPACT_SUMMARY_LEGS = Object.freeze(['engine', 'local_fallback', 'local_fallback_unavailable', 'none']);
+const frozen = (t) => Object.freeze({ ...t });
+const KEEP = Object.freeze({ executor: 'engine', revokeEngineRun: false, shellRunsHook: false });
+function inSet(set, v) {
+    return typeof v === 'string' && set.includes(v);
+}
+export function compactHookTransition(input) {
+    let latch;
+    let leg;
+    try {
+        latch = readOwnDataValue(input, 'latch');
+        leg = readOwnDataValue(input, 'leg');
+    }
+    catch {
+        return KEEP;
+    }
+    if (!inSet(COMPACT_LATCH_STATES, latch) || !inSet(COMPACT_SUMMARY_LEGS, leg))
+        return KEEP;
+    if (leg === 'none')
+        return latch === 'none' ? frozen({ executor: 'none', revokeEngineRun: false, shellRunsHook: false }) : KEEP;
+    if (leg === 'engine')
+        return KEEP;
+    if (latch === 'fired')
+        return frozen({ executor: 'engine', revokeEngineRun: false, shellRunsHook: false, disclosure: 'engine_outcome_unknown' });
+    if (leg === 'local_fallback') {
+        return latch === 'armed'
+            ? frozen({ executor: 'shell', revokeEngineRun: true, shellRunsHook: true })
+            : frozen({ executor: 'shell', revokeEngineRun: false, shellRunsHook: true });
+    }
+    return frozen({ executor: 'none', revokeEngineRun: false, shellRunsHook: false, disclosure: 'neither_ran' });
+}
+export function compactHookDisclosureSentence(disclosure, lang) {
+    if (disclosure === 'engine_outcome_unknown')
+        return renderMessage(msg('session.hooks.compactTransition.disclosure.engineOutcomeUnknown'), lang);
+    if (disclosure === 'neither_ran')
+        return renderMessage(msg('session.hooks.compactTransition.disclosure.neitherRan'), lang);
+    return '';
+}

package/dist/hooksWireCaps.d.ts

@@ -7,7 +7,7 @@ export interface HooksForWireOptions {
     readonly plan: HooksWirePlan;
 }
 export declare function hooksForWire(opts: HooksForWireOptions): WireHooksConfig | undefined;
-export declare function hooksWirePlan(opts?: HooksWirePlanOptions): HooksWirePlan;
+export declare function hooksWirePlan(opts: HooksWirePlanOptions): HooksWirePlan;
 export declare function __resetHooksWireCapsForTests(): void;
 export declare function fleetHookFailureNoticeCapable(baseUrl: string | undefined): boolean;
 export declare const HOOK_FAILURE_WARN_PREFIX = "Hook error";