@sema-agent/client-core 0.99.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';
@@ -17,17 +18,18 @@ import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, sur
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { frameBindingOf } from '../frameBinding.js';
-import { approvalDecisionHolds, approvalHoldFor, awaitApprovalHolder, claimApprovalCardFor, holdLiveCard, joinLiveCard, liveCardHoldOf, clearSettledApprovals, noteHolderSettledApproval, settledApprovalOf, settledForDurableLane, settledLiveCardOutcome } from './approvalHolds.js';
-import { joinedResolution, resolutionOfDecisionFailure } from './approvalResolution.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 { directFailureVerdictOf, directSafetyStopOf, joinedResolution, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { parkRowDeadlineState } from './parkExpiryJudgements.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
-import { denyAttributionRefusalFromError } from '../wireRefusalCopy.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,61 +458,45 @@ 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 };
-                    let attributionDropped = false;
-                    let attributionRenamed = false;
+                    const ladder = { lastCarried: carriesAttributionKey(attributionKeys), dropped: false, renamed: false };
                     let raw;
-                    lastSendCarriedAttribution = carriesAttributionKey(attributionKeys);
+                    lastSendCarriedAttribution = ladder.lastCarried;
                     emitAnswerCommitted(callKey, 'decide', card, denyPayload);
                     try {
-                        raw = await bridge.decideTool(denyBody, gatedCallId, decideOpts, pending);
+                        raw = await deliverWithAttributionLadder(denyBody, (b) => bridge.decideTool(b, gatedCallId, decideOpts, pending), signal, ladder, (step) => {
+                            hostLog('debug', step === 'renamed'
+                                ? `liveToolApprovalWire: decide(deny) for task ${taskId} 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: decide(deny) for task ${taskId} 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: 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 });
                     }
-                    catch (first) {
-                        if (shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal)) {
-                            const withoutAttribution = withoutAttributionKey(denyBody);
-                            lastSendCarriedAttribution = false;
-                            hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} 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)');
-                            raw = await bridge.decideTool(withoutAttribution, gatedCallId, decideOpts, pending);
-                            attributionDropped = true;
-                        }
-                        else if (shouldResendUnderSuccessorKey(first, Object.hasOwn(denyBody, 'settledBy'), signal)) {
-                            const renamed = withAttributionKeyRenamed(denyBody);
-                            hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} 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)');
-                            try {
-                                raw = await bridge.decideTool(renamed, gatedCallId, decideOpts, pending);
-                                attributionRenamed = true;
-                            }
-                            catch (second) {
-                                if (!shouldResendWithoutAttribution(second, true, signal))
-                                    throw second;
-                                const renamedWithoutAttribution = withoutAttributionKey(renamed);
-                                lastSendCarriedAttribution = false;
-                                hostLog('debug', `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)');
-                                raw = await bridge.decideTool(renamedWithoutAttribution, gatedCallId, decideOpts, pending);
-                                attributionDropped = true;
-                            }
-                        }
-                        else {
-                            throw first;
-                        }
+                    finally {
+                        lastSendCarriedAttribution = ladder.lastCarried;
+                        ladderSafetyStop = ladder.safetyStop;
                     }
+                    const attributionDropped = ladder.dropped;
+                    const attributionRenamed = ladder.renamed;
                     const receipt = readDecideReceipt(raw);
                     const deny = denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed);
                     return {
@@ -516,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, {
@@ -524,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 } : {}),
                     });
                 }
             }
@@ -607,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 {};
@@ -872,39 +853,11 @@ function readPersistedRuleAnchors(v) {
 function isNonNegativeSafeInt(v) {
     return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
 }
-function shouldResendWithoutAttribution(e, sentAttributionKey, signal) {
-    if (!sentAttributionKey)
-        return false;
-    if (signal?.aborted === true)
-        return false;
-    return denyAttributionRefusalFromError(e, true)?.kind === 'not_in_proof';
-}
-function shouldResendUnderSuccessorKey(e, lastSendCarriedRetiredKey, signal) {
-    if (!lastSendCarriedRetiredKey)
-        return false;
-    if (signal?.aborted === true)
-        return false;
-    return denyAttributionRefusalFromError(e, true)?.kind === 'retired_key';
-}
 export function decisionAttributionKeyOf(reading, denySettledBy) {
     if (denySettledBy !== 'policy')
         return {};
     return approvalDecidedByAdmitted(reading) ? { decidedBy: 'policy' } : { settledBy: 'policy' };
 }
-function carriesAttributionKey(body) {
-    return Object.hasOwn(body, 'settledBy') || Object.hasOwn(body, 'decidedBy');
-}
-function withoutAttributionKey(body) {
-    const { settledBy: _droppedSettledBy, decidedBy: _droppedDecidedBy, ...rest } = body;
-    void _droppedSettledBy;
-    void _droppedDecidedBy;
-    return rest;
-}
-function withAttributionKeyRenamed(body) {
-    const { settledBy, decidedBy: _replaced, ...rest } = body;
-    void _replaced;
-    return settledBy === undefined ? rest : { ...rest, decidedBy: settledBy };
-}
 function readDecidedByReadingOf(holder) {
     try {
         return readOwnDataValue(holder, 'approvalDecidedBy');
@@ -986,7 +939,7 @@ function probeCauseSentence(cause, withProse, lang) {
         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);
+        return renderMessage(withCode ? msg(key, { code: displayUntrusted(code) }) : msg(key), lang);
     }
     catch {
         return undefined;
@@ -1005,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;
@@ -1021,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;
     }
@@ -1132,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;
@@ -1156,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')) {
@@ -1190,7 +1133,7 @@ export function classifierNoRulingDetail(word, lang) {
         return renderMessage(msg(CLASSIFIER_NO_RULING_REASONS[word]), lang);
     }
     if (typeof word === 'string' && CAUSE_WORD.test(word))
-        return renderMessage(msg('approval.classifier.noRulingOther', { reason: word }), lang);
+        return renderMessage(msg('approval.classifier.noRulingOther', { reason: displayUntrusted(word) }), lang);
     return renderMessage(msg('approval.classifier.noRulingBare'), lang);
 }
 export function approvalBoundGrantsDetail(grants, lang) {
@@ -1863,7 +1806,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         return { kind: 'not_sent', lane: 'respond', cause: 'retracted' };
     }
     if (card.kind === 'aborted') {
-        hold.phase = 'respond';
+        enterLiveRespondPhase(hold);
         const interruptOpts = lane?.approvalDecisionNoteCapable === true ? { note: INTERRUPT_DENY_REASON } : {};
         let interruptDeny;
         try {
@@ -1877,7 +1820,7 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
         hostLog('debug', `liveToolApprovalWire: ${approvalId} card aborted — one tool-level deny issued to settle the pending ask`);
         return { kind: 'unsettled', lane: 'respond', cause: 'interrupted' };
     }
-    hold.phase = 'respond';
+    enterLiveRespondPhase(hold);
     const noteCapable = lane?.approvalDecisionNoteCapable === true;
     const denyReasonRead = card.kind === 'deny' ? ((r) => (typeof r === 'string' ? r : undefined))(card.reason) : undefined;
     const answerSnapshot = card.kind === 'deny'
@@ -1892,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}`);
@@ -1973,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 } : {}),
@@ -1982,56 +1926,56 @@ async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, st
             ...(note !== undefined ? { note } : {}),
             ...attributionKeys,
         };
-        let attributionDropped = false;
-        let attributionRenamed = false;
+        const ladder = { lastCarried: lastSendCarriedAttribution, dropped: false, renamed: false };
         let raw;
         if (basePayload !== undefined)
             emitAnswerCommitted(liveFrameCallKey(approvalId), 'respond', answerSnapshot, basePayload);
         try {
-            raw = await respond(approvalId, decision, respondOpts);
-        }
-        catch (first) {
-            if (shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal)) {
-                const withoutAttribution = withoutAttributionKey(respondOpts);
-                lastSendCarriedAttribution = false;
-                hostLog('debug', `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)');
-                raw = await respond(approvalId, decision, withoutAttribution);
-                attributionDropped = true;
-            }
-            else if (shouldResendUnderSuccessorKey(first, Object.hasOwn(respondOpts, 'settledBy'), signal)) {
-                const renamed = withAttributionKeyRenamed(respondOpts);
-                hostLog('debug', `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)');
-                try {
-                    raw = await respond(approvalId, decision, renamed);
-                    attributionRenamed = true;
-                }
-                catch (second) {
-                    if (!shouldResendWithoutAttribution(second, true, signal))
-                        throw second;
-                    const renamedWithoutAttribution = withoutAttributionKey(renamed);
-                    lastSendCarriedAttribution = false;
-                    hostLog('debug', `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)');
-                    raw = await respond(approvalId, decision, renamedWithoutAttribution);
-                    attributionDropped = true;
-                }
-            }
-            else {
-                throw first;
+            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)'
+                        : 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;
+        }
+        const attributionDropped = ladder.dropped;
+        const attributionRenamed = ladder.renamed;
         const parkingBody = readToolApprovalRespondParking(raw);
         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)'} — ` +
@@ -2131,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";