@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/hitl/toolApprovalWire.js

@@ -1,13 +1,13 @@
 import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, denyReasonForWire, findPendingForTask, readWireErrorCodeReading, } from './hitlBridge.js';
 import { askParkRowArm } from './askParkRowRouting.js';
 import { parkGateArmOf } from './frameRouter.js';
-import { seatSessionRowOf } from './standingRows.js';
+import { seatAllowNoteCarriedOf, seatSessionRowOf } from './standingRows.js';
 import { hostLog } from '../host.js';
 import { trimEditedRuleText } from './editedRuleTextPrecheck.js';
-import { appendOwnElement, guardedRead, readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
+import { appendOwnElement, guardedRead, ownSendableField, ownSnapshot, readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { ownReadingSlot } from '../engineWireFor.js';
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPair } from './askClassPair.js';
-import { approvalAgentIdOf, approvalAskReasonsOf } from './approvalAskers.js';
+import { approvalAgentIdOf, approvalAskReasonsOf, approvalRequestedByOf } from './approvalAskers.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { approvalWindowKeysOf, readApprovalCardWord, readRequiresRealApproval } from './approvalCardReading.js';
 import { readAllowRuleShadowFromWire, retiredAllowRuleShadowKeyPresent, RETIRED_SHADOW_EVIDENCE_LABEL } from './allowRuleShadow.js';
@@ -17,26 +17,29 @@ import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
 import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { sessionAllowCarried, sessionAllowEligible } from './sessionAllowRoute.js';
-import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
+import { INTERRUPT_DENY_REASON, interruptDenyLifetime, observeCancelByDeny, surfaceApprovalParking, surfaceAllowNoteNotCarried, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted, quoteUntrustedForSentence } 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 { directFailureVerdictOf, directSafetyStopOf, joinedResolution, resolutionOfDecisionFailure } from './approvalResolution.js';
+import { directFailureVerdictOf, directSafetyStopOf, joinedResolution, resolutionOfDecisionFailure, toolPermissionSettledElsewhereOf } from './approvalResolution.js';
+import { hostWithdrawalOf } from './hostWithdrawal.js';
 import { parkRowDeadlineState } from './parkExpiryJudgements.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
+import { editedApprovalAcceptanceOf } from './editedApprovalAcceptance.js';
 import { readPolicyDenyCause } from './policyDenyCause.js';
-import { inValueOf, slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { inValueOf, slotPresenceOf, slotReadOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { APPROVAL_LIVE_FACE_KEYS, approvalLiveFaceOf, hasOwnStrictTrue } from './approvalLiveFace.js';
-import { approvalFrameUnreadableWhyOf, approvalRequestFrameReadingThrowing, } from './approvalRequestFrameReading.js';
+import { approvalFrameUnreadableWhyOf, approvalRequestFrameReadingThrowing, cardPayloadReadingOf, } from './approvalRequestFrameReading.js';
 import { subagentSourceSessionOf } from './subagentSource.js';
 import { isPlainRecord } from '../jsonFaithful.js';
 import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
+import { sourceGenerationBit, sourceGenerationNow } from './screenCardCarriers.js';
 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();
@@ -98,10 +101,19 @@ export function readApprovalDenySettledBy(decision) {
         : undefined;
 }
 export const RETRACTED_CARD_DECISION_KIND = 'retracted';
-function parkRowOf(taskId, row, gatedCallId) {
+export const WITHDRAWN_CARD_DECISION_KIND = 'withdrawn';
+function withdrawnCardResolution(card, at, logTag) {
+    const w = hostWithdrawalOf(card);
+    if (w === undefined) {
+        hostLog('debug', `${logTag}: card-withdrawn-unreadable as=retracted`);
+        return { kind: 'not_sent', ...at, cause: 'retracted' };
+    }
+    hostLog('debug', `${logTag}: card-withdrawn-by-host verdict=${w.rowVerdict.kind}`);
+    return { kind: 'not_sent', ...at, cause: 'withdrawn', toldBy: w.toldBy, rowVerdict: w.rowVerdict };
+}
+function parkRowOf(row, gatedCallId) {
     const d = parkRowDeadlineState(row, Date.now());
     return Object.freeze({
-        taskId,
         ...(gatedCallId !== undefined && gatedCallId !== '' ? { gatedCallId } : {}),
         ...(d.kind !== 'none' ? { deadlineMs: d.deadlineMs } : {}),
     });
@@ -174,6 +186,16 @@ export function rememberRefusalOf(error) {
 function rememberRefusalIn(reading) {
     return reading.state === 'code' ? REMEMBER_REFUSAL_CODES.find((c) => c === reading.code) : undefined;
 }
+const FEEDBACK_REFUSAL_CODES = Object.freeze(['feedback_not_in_proof']);
+function feedbackRefusalOf(error) {
+    const reading = readWireErrorCodeReading(error);
+    return reading.state === 'code' && FEEDBACK_REFUSAL_CODES.some((c) => c === reading.code);
+}
+function approveBodyWithoutFeedback(body) {
+    const { feedback: _feedback, ...rest } = body;
+    void _feedback;
+    return rest;
+}
 function logAfterDecided(msg) {
     try {
         hostLog('debug', msg);
@@ -203,12 +225,10 @@ const PARK_ROW_ARGS_TRUNCATED_NOTE = "this request's tool arguments were too lar
     'Edits are not accepted on this card: there is no original input to edit';
 const ARGS_REWRITTEN_NOTE = "this request's tool arguments were changed after the model made the call (for example by a hook) — " +
     'the arguments shown here are the changed ones recorded for this approval, and they differ from the call shown in the conversation';
-const ARGS_FROM_MODEL_CALL_NOTE = 'this approval request did not carry usable tool arguments (for example because they were too large to include), ' +
-    "so the arguments shown are the model's original call from the conversation — " +
-    'if they were changed after that call (for example by a hook), what runs differs from what is shown';
-const PARK_EDIT_REFUSED_REASON = "the card returned an edited approval, but this request's tool arguments are not available on this surface " +
-    '(missing, or replaced by a size marker on the pending approval record), so the edit cannot be applied — nothing was sent; ' +
-    'approve or deny it as it is';
+function argsFromModelCallBitsOf() {
+    return { argsUnavailable: true, wireNote: renderMessage(msg('approval.park.argsFromModelCall')) };
+}
+const parkEditRefusedReason = () => renderMessage(msg('approval.editRefusal.parkReason', { stem: msg('approval.editRefusal.stem') }));
 function isParkRowInputSizeMarker(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
         return false;
@@ -249,6 +269,14 @@ function cardInputOf(recorded, stream) {
         return { from: 'stream', args: stream, shape };
     return { from: 'none', shape, recorded };
 }
+function inputSourceBitOf(reading) {
+    return reading.from === 'recorded' ? { inputSource: 'record' } : reading.from === 'stream' ? { inputSource: 'stream' } : {};
+}
+function approvalInputSourceOf(card) {
+    const raw = ownDataValue(card, 'inputSource');
+    const known = { record: true, stream: true };
+    return typeof raw === 'string' && Object.hasOwn(known, raw) ? raw : undefined;
+}
 const CARD_ARGS_COMPARE_MAX_NODES = 20_000;
 const CARD_ARGS_COMPARE_MAX_DEPTH = 256;
 const NOT_COMPARABLE = Symbol('not comparable');
@@ -442,6 +470,7 @@ async function joinDurableDecision(hold, deps, signal) {
 }
 export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signal, parkGatedCallId, parkToolName) {
     const decidedByReading = decidedByReadingSnapshotOf(deps);
+    const sourceGeneration = sourceGenerationNow(deps);
     const readMark = openDurableRead();
     let found;
     let held;
@@ -471,7 +500,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
     const fetched = found;
     return holdDurableDecision(durableHoldKey(fetched.pending, callKey), rowIdentity, signal, async (hold) => {
         const slot = {};
-        const out = await presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, fetched, decidedByReading, callKey, hold, slot);
+        const out = await presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, fetched, decidedByReading, callKey, hold, slot, sourceGeneration);
         noteCallOutcome(slot, out);
         return out;
     });
@@ -485,7 +514,7 @@ function parkRowHolderIdentity(row, gatedCallId) {
         ...(askSig !== undefined ? { askSig } : {}),
     };
 }
-async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, found, decidedByReading, callKey, hold, ledgerSlot) {
+async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, found, decidedByReading, callKey, hold, ledgerSlot, sourceGeneration) {
     const { pending, gatedCallId } = found;
     const at = { lane: 'decide', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     const toolName = typeof pending.toolName === 'string' ? pending.toolName : '';
@@ -518,7 +547,8 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
             }
             : {}),
         ...(argsRewritten ? { argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE } : {}),
-        ...(argsFromModelCall ? { argsUnavailable: true, wireNote: renderMessage(msg('approval.park.argsFromModelCall')) } : {}),
+        ...(argsFromModelCall ? argsFromModelCallBitsOf() : {}),
+        ...inputSourceBitOf(reading),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(pending) ? { requiresRealApproval: true } : {}),
         ...approvalLiveFaceOf(pending).facts,
@@ -540,14 +570,17 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
             : {}),
         allowSessionCarried: true,
         grantBinding: readApprovalGrantBinding(pending),
-        parkRow: parkRowOf(taskId, pending, gatedCallId),
+        parkRow: parkRowOf(pending, gatedCallId),
+        ...(typeof taskId === 'string' && taskId !== '' ? { taskId } : {}),
+        ...sourceGenerationBit(sourceGeneration),
     });
+    const editAcceptance = editedApprovalAcceptanceOf(cardRequest);
     const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, cardRequest);
     hold.phase = 'respond';
-    if ((rowArgsGap !== undefined || argsFromModelCall) && card.kind === 'allow' && card.updatedInput !== undefined) {
+    if (editAcceptance.state !== 'accepts' && card.kind === 'allow' && card.updatedInput !== undefined) {
         hostLog('error', `liveToolApprovalWire: approval card for ${gatedCallId ?? `task ${taskId}`} returned an edited approval, but the tool input is ${rowArgsGap === 'truncated' ? 'a size marker on the pending row' : rowArgsGap === 'absent' ? 'missing from both the stream and the pending row' : 'not recorded on the pending row'} — nothing sent (the park stays pending)`);
         surfaceEditRefusedOnBlindAsk();
-        return { kind: 'not_sent', ...at, cause: 'edit_refused', detail: PARK_EDIT_REFUSED_REASON };
+        return { kind: 'not_sent', ...at, cause: 'edit_refused', detail: parkEditRefusedReason() };
     }
     const decideSpan = bridge.openDecideOperation();
     const decideOpts = { ...(signal ? { signal } : {}), operation: decideSpan };
@@ -558,9 +591,11 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
             case 'retracted':
                 hostLog('debug', `liveHitlAskWire: approval card retracted without a decision for ${gatedCallId ?? '(no call)'} — nothing sent`);
                 return { kind: 'not_sent', ...at, cause: 'retracted' };
+            case WITHDRAWN_CARD_DECISION_KIND:
+                return withdrawnCardResolution(card, at, 'liveHitlAskWire');
             case 'aborted':
                 {
-                    const cancelDeny = bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, undefined, pending);
+                    const cancelDeny = bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, { signal: interruptDenyLifetime() }, pending);
                     hold.trailing = cancelDeny;
                     observeCancelByDeny(cancelDeny, taskId);
                 }
@@ -578,11 +613,30 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const { remember: _remember, ...plainApproveBody } = approveBody;
                     void _remember;
                     emitAnswerCommitted(callKey, 'decide', answered, approveBody);
+                    let feedbackDropped = false;
+                    const sendApprove = async (body) => {
+                        const wire = feedbackDropped ? approveBodyWithoutFeedback(body) : body;
+                        try {
+                            return await bridge.decideTool(wire, gatedCallId, decideOpts, pending);
+                        }
+                        catch (e) {
+                            if (wire.feedback === undefined || !feedbackRefusalOf(e))
+                                throw e;
+                            const verdict = directFailureVerdictOf(e, directSafetyStopOf(e));
+                            if (verdict.yields) {
+                                rememberStop = ownReadingSlot(verdict, 'directStop');
+                                throw e;
+                            }
+                            feedbackDropped = true;
+                            logAfterDecided(`liveToolApprovalWire: decide(approve+feedback) refused the feedback part (${String(e)}) — resending without the note`);
+                            return await bridge.decideTool(approveBodyWithoutFeedback(wire), gatedCallId, decideOpts, pending);
+                        }
+                    };
                     if (approveBody.remember === 'session') {
                         let sessionReceipt;
                         let sessionDecided = false;
                         try {
-                            const raw = await bridge.decideTool(approveBody, gatedCallId, decideOpts, pending);
+                            const raw = await sendApprove(approveBody);
                             sessionReceipt = readDecideReceipt(raw);
                             sessionDecided = true;
                         }
@@ -600,13 +654,17 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                         if (sessionDecided) {
                             if (sessionReceipt?.rememberApplied === false)
                                 surfaceRememberNotApplied();
+                            if (feedbackDropped)
+                                surfaceAllowNoteNotCarried(allowNoteNotCarriedSentence());
                             return { kind: 'decided', ...at, decision: 'allow', ...(sessionReceipt !== undefined ? { receipt: sessionReceipt } : {}) };
                         }
                     }
-                    const raw = await bridge.decideTool(plainApproveBody, gatedCallId, decideOpts, pending);
+                    const raw = await sendApprove(plainApproveBody);
                     const receipt = readDecideReceipt(raw);
                     if (rememberRefused || sessionDowngraded)
                         surfaceRememberNotApplied();
+                    if (feedbackDropped)
+                        surfaceAllowNoteNotCarried(allowNoteNotCarriedSentence());
                     return { kind: 'decided', ...at, decision: 'allow', ...(receipt !== undefined ? { receipt } : {}) };
                 }
                 catch (e) {
@@ -770,6 +828,12 @@ export function toolPermissionRequestAskBits(card, requestId) {
     const origin = readAskOrigin(card);
     const ruleOffersAbsence = readOwnNonEmptyString(card, 'ruleOffersAbsence');
     const askClassPair = readAskClassPair(card);
+    const probeLayer = probeCarrierOf(card);
+    const probe = probeFactsAt(probeLayer);
+    const onTop = probeLayer === card;
+    const requestedBy = onTop ? approvalRequestedByOf(card) : undefined;
+    const payload = onTop ? cardPayloadReadingOf(card) : undefined;
+    const inputSource = onTop ? approvalInputSourceOf(card) : undefined;
     return {
         ...(mandated ? { mandated: true } : {}),
         ...(mandate !== undefined ? { mandate } : {}),
@@ -777,6 +841,12 @@ export function toolPermissionRequestAskBits(card, requestId) {
         ...(ruleOffersAbsence !== undefined ? { ruleOffersAbsence } : {}),
         ...(askClassPair ?? {}),
         ...(seatSessionRowOf(card, requestId) ? { sessionRow: true } : {}),
+        ...(probe.prose !== undefined ? { probeReason: probe.prose } : {}),
+        ...(probe.cause !== undefined ? { probeCause: probe.cause } : {}),
+        ...(seatAllowNoteCarriedOf(card, requestId) ? { feedbackCapable: true } : {}),
+        ...(requestedBy !== undefined ? { requestedBy } : {}),
+        ...(payload !== undefined && payload.payloadUnreadable && payload.why !== undefined ? { frameReading: payload.why } : {}),
+        ...(inputSource !== undefined ? { inputSource } : {}),
     };
 }
 function isToolApprovalDelegation(v) {
@@ -803,6 +873,14 @@ function respondDecisionOfAnswer(answer) {
         return answer.allowSession ? 'allow_session' : 'allow';
     return answer.kind === 'deny' ? 'deny' : undefined;
 }
+export function allowNoteReadingOf(answer) {
+    const note = readOwnDataValue(answer, 'note');
+    if (note === undefined)
+        return { kind: 'absent' };
+    if (typeof note !== 'string')
+        return { kind: 'invalid' };
+    return note.trim() === '' ? { kind: 'blank' } : { kind: 'text', text: note };
+}
 function respondNoteGate(reason, capable) {
     if (reason === undefined || reason.trim() === '')
         return { dropped: 'blank' };
@@ -821,10 +899,14 @@ export function answerPayloadFor(answer, lane, caps) {
             const reason = answer.kind === 'deny' && typeof answer.reason === 'string' ? answer.reason : undefined;
             return Object.freeze({ decision: 'deny', reason: denyReasonForWire(reason, 'answer') ?? DEFAULT_DENY_REASON });
         }
+        const fb = allowNoteReadingOf(answer);
+        if (fb.kind === 'invalid')
+            hostLog('error', `answerPayloadFor: the allow note must be a string (got ${typeof readOwnDataValue(answer, 'note')}) — not sent as feedback; the decision itself is sent`);
         return Object.freeze({
             decision: 'approve',
             ...(word === 'allow_session' ? { remember: 'session' } : {}),
             ...(answer.updatedInput !== undefined ? { updatedInput: answer.updatedInput } : {}),
+            ...(fb.kind === 'text' ? { feedback: fb.text } : {}),
         });
     }
     if (answer.kind === 'allow')
@@ -833,9 +915,25 @@ export function answerPayloadFor(answer, lane, caps) {
     return Object.freeze({ decision: word, ...('note' in gate ? { note: gate.note } : {}) });
 }
 const ANSWER_CARRIAGE_NONE = Object.freeze({ allowNote: 'none' });
+const ANSWER_CARRIAGE_MODEL = Object.freeze({ allowNote: 'model' });
 export function answerCarriage(card) {
-    void card;
-    return ANSWER_CARRIAGE_NONE;
+    return cardIsOnParkRow(card) ? ANSWER_CARRIAGE_MODEL : ANSWER_CARRIAGE_NONE;
+}
+export function cardIsOnParkRow(card) {
+    try {
+        if (typeof card !== 'object' || card === null)
+            return false;
+        const park = readOwnDataValue(card, 'parkRow');
+        if (typeof park !== 'object' || park === null || Array.isArray(park))
+            return false;
+        return readOwnDataNonEmptyString(card, 'taskId') !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+export function allowNoteNotCarriedSentence(lang) {
+    return renderMessage(msg('approval.allowNote.notCarried'), lang);
 }
 export function observeApprovalAnswerCommitted(listener) {
     answerCommittedListeners.add(listener);
@@ -852,37 +950,63 @@ function emitAnswerCommitted(callKey, lane, answer, payload) {
         invokeHostCallbackIsolated('liveToolApprovalWire: answer-committed listener', () => l(event));
 }
 export function isToolApprovalRespondReplayed(ack) {
-    return typeof ack === 'object' && ack !== null && ack.idempotent === true;
+    return typeof ack === 'object' && ack !== null && ack.idempotent === true && ack.accepted !== 'parked_redeemed';
+}
+export function isToolApprovalRespondParkedRedeemed(ack) {
+    return typeof ack === 'object' && ack !== null && ack.accepted === 'parked_redeemed';
+}
+export function replayedFirstDecisionOf(ack) {
+    if (ack === undefined)
+        return undefined;
+    if (isToolApprovalRespondReplayed(ack))
+        return ack.decision;
+    if (isToolApprovalRespondParkedRedeemed(ack) && ack.idempotent === true)
+        return ack.decision === 'allow' || ack.decision === 'deny' ? ack.decision : undefined;
+    return undefined;
+}
+export function settlementAckOf(read) {
+    return read !== undefined && isToolApprovalRespondParkedRedeemed(read) && read.idempotent !== true ? undefined : read;
 }
 export function readToolApprovalRespondAck(v) {
     if (v === null || typeof v !== 'object')
         return undefined;
-    const o = v;
-    if (o.idempotent === true)
-        return o.delivery === undefined ? readReplayedAck(o) : undefined;
-    if (o.delivery !== 'applied')
-        return undefined;
-    if (typeof o.approvalId !== 'string' || o.approvalId.length === 0)
-        return undefined;
-    if (!isRespondDecision(o.decision))
-        return undefined;
+    const s = respondAckSlotsOf(v);
+    if (s.accepted.presence === 'unreadable' || s.idempotent.presence === 'unreadable' || s.delivery.presence === 'unreadable')
+        return undefined;
+    if (slotValueOf(s.accepted) === 'parked_redeemed')
+        return readParkedRedeemedAck(s);
+    if (slotValueOf(s.idempotent) === true)
+        return s.delivery.presence === 'absent' ? readReplayedAck(s) : undefined;
+    if (slotValueOf(s.delivery) !== 'applied')
+        return undefined;
+    const approvalId = slotValueOf(s.approvalId);
+    const decision = slotValueOf(s.decision);
+    if (typeof approvalId !== 'string' || approvalId.length === 0)
+        return undefined;
+    if (!isRespondDecision(decision))
+        return undefined;
+    const rememberApplied = slotValueOf(s.rememberApplied);
+    const updatedInputForwarded = slotValueOf(s.updatedInputForwarded);
+    const rulePersisted = slotValueOf(s.rulePersisted);
+    const ruleRefusal = slotValueOf(s.ruleRefusal);
+    const noteRecorded = slotValueOf(s.noteRecorded);
+    const persistedRule = slotValueOf(s.persistedRule);
+    const persistedRules = slotValueOf(s.persistedRules);
+    const anchors = readPersistedRuleAnchors(slotValueOf(s.persistedRuleAnchors));
     const out = {
-        approvalId: o.approvalId,
+        approvalId,
         delivery: 'applied',
-        decision: o.decision,
-        ...(typeof o.rememberApplied === 'boolean' ? { rememberApplied: o.rememberApplied } : {}),
-        ...(typeof o.updatedInputForwarded === 'boolean' ? { updatedInputForwarded: o.updatedInputForwarded } : {}),
-        ...(typeof o.rulePersisted === 'boolean' ? { rulePersisted: o.rulePersisted } : {}),
-        ...(typeof o.ruleRefusal === 'string' && o.ruleRefusal !== ''
-            ? { ruleRefusal: o.ruleRefusal }
+        decision: decision,
+        ...(typeof rememberApplied === 'boolean' ? { rememberApplied } : {}),
+        ...(typeof updatedInputForwarded === 'boolean' ? { updatedInputForwarded } : {}),
+        ...(typeof rulePersisted === 'boolean' ? { rulePersisted } : {}),
+        ...(typeof ruleRefusal === 'string' && ruleRefusal !== ''
+            ? { ruleRefusal: ruleRefusal }
             : {}),
-        ...(typeof o.noteRecorded === 'boolean' ? { noteRecorded: o.noteRecorded } : {}),
-        ...(typeof o.persistedRule === 'string' && o.persistedRule !== '' ? { persistedRule: o.persistedRule } : {}),
-        ...(isNonEmptyStringArray(o.persistedRules) ? { persistedRules: o.persistedRules } : {}),
-        ...(() => {
-            const anchors = readPersistedRuleAnchors(o.persistedRuleAnchors);
-            return anchors !== undefined ? { persistedRuleAnchors: anchors } : {};
-        })(),
+        ...(typeof noteRecorded === 'boolean' ? { noteRecorded } : {}),
+        ...(typeof persistedRule === 'string' && persistedRule !== '' ? { persistedRule } : {}),
+        ...(isNonEmptyStringArray(persistedRules) ? { persistedRules: persistedRules.slice() } : {}),
+        ...(anchors !== undefined ? { persistedRuleAnchors: anchors } : {}),
     };
     if (out.persistedRule !== undefined && (out.persistedRules !== undefined || out.persistedRuleAnchors !== undefined)) {
         delete out.persistedRule;
@@ -903,6 +1027,35 @@ export function readToolApprovalRespondAck(v) {
     }
     return out;
 }
+const RESPOND_ACK_SLOT_KEYS = [
+    'accepted',
+    'idempotent',
+    'delivery',
+    'approvalId',
+    'askId',
+    'decision',
+    'decidedAtMs',
+    'decisionNote',
+    'rememberApplied',
+    'updatedInputForwarded',
+    'rulePersisted',
+    'ruleRefusal',
+    'noteRecorded',
+    'persistedRule',
+    'persistedRules',
+    'persistedRuleAnchors',
+];
+function respondAckSlotsOf(o) {
+    const slots = {};
+    for (const key of RESPOND_ACK_SLOT_KEYS) {
+        const slot = slotReadOf(o, key);
+        slots[key] = slot.presence === 'present' ? { presence: 'present', value: ownSnapshot(slot.value) } : slot;
+    }
+    return slots;
+}
+function slotValueOf(slot) {
+    return slot.presence === 'present' ? slot.value : undefined;
+}
 export function readToolApprovalRespondParking(v) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -945,6 +1098,17 @@ function replayClaimOf(raw) {
     }
     return { ...(approvalId !== undefined ? { approvalId } : {}), ...(d === 'allow' || d === 'deny' ? { decision: d } : {}), carriesDelivery };
 }
+function idempotentSlotUnreadable(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return false;
+    try {
+        const d = Object.getOwnPropertyDescriptor(raw, 'idempotent');
+        return d !== undefined && !Object.hasOwn(d, 'value');
+    }
+    catch {
+        return true;
+    }
+}
 function ownIdempotentTrue(raw) {
     if (typeof raw !== 'object' || raw === null)
         return false;
@@ -956,27 +1120,103 @@ function ownIdempotentTrue(raw) {
         return false;
     }
 }
-function readReplayedAck(o) {
-    if (typeof o.approvalId !== 'string' || o.approvalId.length === 0)
+export function replayVerdictFrom(raw, parsed, approvalId) {
+    if (parsed !== undefined && isToolApprovalRespondReplayed(parsed) && parsed.approvalId === approvalId)
+        return { kind: 'replayed', firstDecision: parsed.decision, via: 'arm' };
+    if (!(ownIdempotentTrue(raw) || replayedFirstDecisionOf(parsed) !== undefined))
+        return idempotentSlotUnreadable(raw) ? { kind: 'unreadable' } : { kind: 'none' };
+    const claimed = replayClaimOf(raw);
+    if (claimed.approvalId === approvalId && claimed.decision !== undefined && !claimed.carriesDelivery)
+        return { kind: 'replayed', firstDecision: claimed.decision, via: 'claim' };
+    return { kind: 'unreadable' };
+}
+const REPLAY_VERDICT_NONE = Object.freeze({ kind: 'not_replay' });
+const REPLAY_VERDICT_ALLOW = Object.freeze({ kind: 'replayed', firstDecision: 'allow' });
+const REPLAY_VERDICT_DENY = Object.freeze({ kind: 'replayed', firstDecision: 'deny' });
+const REPLAY_VERDICT_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+export function toolApprovalReplayVerdictOf(raw, approvalId) {
+    try {
+        if (typeof approvalId !== 'string' || approvalId === '')
+            return REPLAY_VERDICT_UNREADABLE;
+        const v = replayVerdictFrom(raw, settlementAckOf(readToolApprovalRespondAck(raw)), approvalId);
+        if (v.kind === 'none')
+            return REPLAY_VERDICT_NONE;
+        if (v.kind === 'replayed')
+            return v.firstDecision === 'allow' ? REPLAY_VERDICT_ALLOW : REPLAY_VERDICT_DENY;
+        return REPLAY_VERDICT_UNREADABLE;
+    }
+    catch {
+        return REPLAY_VERDICT_UNREADABLE;
+    }
+}
+function readReplayedAck(s) {
+    const approvalId = slotValueOf(s.approvalId);
+    const askId = slotValueOf(s.askId);
+    const decision = slotValueOf(s.decision);
+    const decidedAtMs = slotValueOf(s.decidedAtMs);
+    const decisionNote = slotValueOf(s.decisionNote);
+    if (typeof approvalId !== 'string' || approvalId.length === 0)
         return undefined;
-    if (typeof o.askId !== 'string' || o.askId.length === 0)
+    if (typeof askId !== 'string' || askId.length === 0)
         return undefined;
-    if (o.decision !== 'allow' && o.decision !== 'deny')
+    if (decision !== 'allow' && decision !== 'deny')
         return undefined;
-    if (typeof o.decidedAtMs !== 'number' || !Number.isFinite(o.decidedAtMs) || o.decidedAtMs < 0)
+    if (typeof decidedAtMs !== 'number' || !Number.isFinite(decidedAtMs) || decidedAtMs < 0)
         return undefined;
     return {
-        approvalId: o.approvalId,
-        askId: o.askId,
+        approvalId,
+        askId,
         idempotent: true,
-        decision: o.decision,
-        decidedAtMs: o.decidedAtMs,
-        ...(typeof o.decisionNote === 'string' && o.decisionNote !== '' ? { decisionNote: o.decisionNote } : {}),
-        ...(o.rememberApplied === false ? { rememberApplied: false } : {}),
+        decision,
+        decidedAtMs,
+        ...(typeof decisionNote === 'string' && decisionNote !== '' ? { decisionNote } : {}),
+        ...(slotValueOf(s.rememberApplied) === false ? { rememberApplied: false } : {}),
     };
 }
+function readParkedRedeemedAck(s) {
+    if (s.delivery.presence !== 'absent')
+        return undefined;
+    const text = (slot) => {
+        const v = slotValueOf(slot);
+        return typeof v === 'string' && v !== '' ? v : undefined;
+    };
+    const approvalId = text(s.approvalId);
+    const askId = text(s.askId);
+    if (approvalId === undefined || askId === undefined)
+        return undefined;
+    const replay = slotValueOf(s.idempotent) === true;
+    const dec = slotValueOf(s.decision);
+    let decision;
+    if (replay) {
+        if (dec !== 'allow' && dec !== 'deny')
+            return undefined;
+        decision = dec;
+    }
+    else {
+        decision = typeof dec === 'string' && dec !== '' ? dec : undefined;
+    }
+    const remember = slotValueOf(s.rememberApplied);
+    return {
+        approvalId,
+        askId,
+        accepted: 'parked_redeemed',
+        ...(replay ? { idempotent: true } : {}),
+        ...(decision !== undefined ? { decision } : {}),
+        ...(typeof remember === 'boolean' ? { rememberApplied: remember } : {}),
+    };
+}
+function replayedDecisionOf(first, sent, ack) {
+    return { kind: 'decided', lane: 'respond', decision: first, ...(ack !== undefined ? { ack } : {}), settledElsewhere: toolPermissionSettledElsewhereOf(first, sent) };
+}
 function isNonEmptyStringArray(v) {
-    return Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string' && x !== '');
+    if (!Array.isArray(v) || v.length === 0)
+        return false;
+    for (let i = 0; i < v.length; i++) {
+        const x = v[i];
+        if (typeof x !== 'string' || x === '')
+            return false;
+    }
+    return true;
 }
 function readPersistedRuleAnchors(v) {
     if (!Array.isArray(v) || v.length === 0)
@@ -1080,19 +1320,44 @@ function readProbeReason(v) {
 function usableProbeReason(raw) {
     return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
 }
+function probeFactsAt(at) {
+    const prose = usableProbeReason(ownDataValue(at, 'probeReason'));
+    let cause;
+    try {
+        const raw = ownDataValue(at, 'probeCause');
+        if (isWireRecordCarrier(raw))
+            cause = raw;
+    }
+    catch {
+        cause = undefined;
+    }
+    return { prose, cause };
+}
+function probeCarrierOf(carrier) {
+    let d;
+    try {
+        d = Object.getOwnPropertyDescriptor(carrier, 'riskDescriptor');
+    }
+    catch {
+        return undefined;
+    }
+    if (d === undefined)
+        return carrier;
+    return Object.hasOwn(d, 'value') ? d.value : 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, lang) {
-    const prose = usableProbeReason(ownDataValue(card, 'probeReason'));
+    const { prose, cause } = probeFactsAt(card);
     const shown = prose === undefined ? '' : displayUntrusted(prose);
-    const sentence = probeCauseSentence(ownDataValue(card, 'probeCause'), shown !== '', lang);
+    const sentence = probeCauseSentence(cause, shown !== '', lang);
     if (sentence === undefined)
         return shown === '' ? undefined : shown;
     return shown === '' ? sentence : renderMessage(msg('approval.probe.proseJoin', { sentence, prose: shown }), lang);
 }
 function probeCauseSentence(cause, withProse, lang) {
+    if (cause === undefined)
+        return undefined;
     try {
-        if (!isWireRecordCarrier(cause))
-            return undefined;
         const code = ownDataValue(cause, 'code');
         const withCode = typeof code === 'string' && PROBE_CAUSE_CODE_WORD.test(code);
         const key = withProse
@@ -1675,6 +1940,67 @@ function subagentBadgeFor(frame) {
         name = `${name.slice(0, 31)}…`;
     return { name, color: 'cyan' };
 }
+const APPROVAL_CARD_FACT_KEYS = [
+    'toolName', 'args', 'toolCallId', 'workerBadge', 'wireNote', 'argsUnavailable', 'inputSource', 'governanceForced', 'delegation', 'ruleOffersReadOnly',
+    'inputHasBidi', 'allowRuleShadow', 'probeCause', 'rememberRefused', 'ruleEvidence', 'requiresRealApproval', 'ruleOffersAbsence', 'denialLimitFallback',
+    'askClass', 'classes', 'agentId', 'askReasons', 'grantBinding', 'unreadableEvidence', 'message', 'approvalCard',
+    'argsRewritten', 'ruleOffers', 'probeReason', 'mandated', 'mandate', 'readRootCandidate', 'origin', 'boundGrants', 'classifierNoRuling',
+    'allowSessionCarried', 'cardPayloadUnreadable', 'cardPayloadUnreadableWhy', 'requestedBy',
+];
+const APPROVAL_CARD_HOST_KEYS = ['callKey', 'taskId', 'signal', 'expiresInMs', 'expiresAtMs', 'serverNowMs', 'receivedAtMs', 'sourceGeneration'];
+const _pinCardRequestPartition = [true, true, true, true, true];
+void _pinCardRequestPartition;
+const FACT_KEY_SET = new Set(APPROVAL_CARD_FACT_KEYS);
+const HOST_KEY_SET = new Set(APPROVAL_CARD_HOST_KEYS);
+function hostBitInDomain(key, v) {
+    switch (key) {
+        case 'callKey':
+        case 'taskId':
+            return typeof v === 'string' && v !== '';
+        case 'signal':
+            return typeof v === 'object' && v !== null;
+        case 'sourceGeneration':
+            return typeof v === 'number' && Number.isFinite(v);
+        default:
+            return typeof v === 'number' && Number.isFinite(v) && v >= 0;
+    }
+}
+function closedKeysListing(from) {
+    try {
+        return { kind: 'listed', keys: Reflect.ownKeys(from) };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+function copyClosedKeys(into, from, keys, admit) {
+    const listed = closedKeysListing(from);
+    if (listed.kind === 'unreadable')
+        return;
+    for (let i = 0; i < listed.keys.length; i += 1) {
+        const k = listed.keys[i];
+        if (typeof k !== 'string' || !keys.has(k))
+            continue;
+        const v = guardedRead(() => ownSendableField(from, k));
+        if (v === undefined || (admit !== undefined && !admit(k, v)))
+            continue;
+        into[k] = v;
+    }
+}
+function cardRequestOf(facts, host) {
+    const out = {};
+    copyClosedKeys(out, facts, FACT_KEY_SET);
+    copyClosedKeys(out, host, HOST_KEY_SET, (k, v) => hostBitInDomain(k, v));
+    return out;
+}
+export function approvalCardRequestOf(facts, host) {
+    if (typeof facts !== 'object' || facts === null || typeof host !== 'object' || host === null)
+        return undefined;
+    const out = cardRequestOf(facts, host);
+    if (typeof out.toolName !== 'string' || typeof out.args !== 'object' || out.args === null || typeof out.callKey !== 'string')
+        return undefined;
+    return out;
+}
 function v1Bit(stamp) {
     try {
         stamp();
@@ -1713,12 +2039,14 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
             if (reading.from === 'recorded') {
                 if (blind)
                     return { args: reading.args, argsUnavailable: true };
-                return reading.rewritten ? { args: reading.args, argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE } : { args: reading.args };
+                return reading.rewritten
+                    ? { args: reading.args, argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE, ...inputSourceBitOf(reading) }
+                    : { args: reading.args, ...inputSourceBitOf(reading) };
             }
             if (reading.from === 'stream' && typeof reading.args === 'object' && reading.args !== null) {
                 if (blind)
                     return { args: reading.args, argsUnavailable: true };
-                return { args: reading.args, wireNote: ARGS_FROM_MODEL_CALL_NOTE };
+                return { args: reading.args, ...argsFromModelCallBitsOf(), ...inputSourceBitOf(reading) };
             }
             const omitted = c.argsOmitted === true || reading.shape === 'size_marker';
             const fallback = argsFallbackOf(c.message, omitted);
@@ -1749,6 +2077,8 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
         out.argsUnavailable = true;
     if (argsPart.argsRewritten === true)
         out.argsRewritten = true;
+    if (argsPart.inputSource !== undefined)
+        out.inputSource = argsPart.inputSource;
     if (full) {
         v1Bit(() => {
             if (c.governanceForced === true)
@@ -1784,6 +2114,11 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
                 if (r !== undefined)
                     out.probeReason = r;
             });
+            v1Bit(() => {
+                const by = approvalRequestedByOf(live);
+                if (by !== undefined)
+                    out.requestedBy = by;
+            });
         }
         v1Bit(() => {
             if (readApprovalRememberRefused(carrier))
@@ -1928,7 +2263,10 @@ export async function surfaceApprovalFrameWithId(frame, approvalId, respond, str
     if (typeof approvalId !== 'string' || approvalId === '')
         return approvalIdUnreadableRefusal();
     const carriers = openingFrameCarriersOf(frame);
-    const entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, frame, carriers, run), respond, streamArgs, signal, lane, receivedAtMs };
+    const liveRun = liveCardRunOf(frame, run);
+    const sourceGenerationRaw = guardedRead(() => readOwnDataValue(run, 'sourceGeneration'));
+    const sourceGeneration = typeof sourceGenerationRaw === 'number' && Number.isFinite(sourceGenerationRaw) ? sourceGenerationRaw : undefined;
+    const entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, carriers, liveRun), respond, streamArgs, signal, lane, receivedAtMs, sourceGeneration };
     return enterLiveCard(entry);
 }
 function openingFrameCarriersOf(frame) {
@@ -1954,7 +2292,7 @@ function enterLiveCard(e) {
         return joinOtherLaneHolder(e, other);
     return holdLiveCard(e.identity, signal, async (hold) => {
         const slot = {};
-        const out = await presentToolApprovalFrameAndRespond(e.frame, e.carriers, approvalId, e.respond, e.streamArgs, signal, e.lane, hold, slot, e.receivedAtMs);
+        const out = await presentToolApprovalFrameAndRespond(e.frame, e.carriers, approvalId, e.respond, e.streamArgs, signal, e.lane, hold, slot, e.receivedAtMs, e.identity.taskId, e.sourceGeneration);
         noteCallOutcome(slot, out);
         return out;
     });
@@ -1969,15 +2307,20 @@ async function joinOtherLaneHolder(e, other) {
         return { kind: 'not_sent', lane: 'respond', cause: 'retracted', joinedInFlight: true };
     return enterLiveCard(e);
 }
-function liveCardIdentityOf(approvalId, frame, carriers, run) {
+function liveCardRunOf(frame, run) {
+    const source = frameBindingOf(frame) ?? run;
+    return {
+        taskId: guardedRead(() => readOwnDataNonEmptyString(source, 'taskId')),
+        sessionId: guardedRead(() => readOwnDataNonEmptyString(source, 'sessionId')),
+    };
+}
+function liveCardIdentityOf(approvalId, carriers, liveRun) {
     const body = carriers.body;
     const toolCallId = typeof body.toolCallId === 'string' && body.toolCallId !== '' ? body.toolCallId : undefined;
     const fromSubagent = isFromSubagent(carriers.body);
-    const bound = fromSubagent ? undefined : frameBindingOf(frame);
-    const source = bound ?? run;
-    const ownRun = fromSubagent ? subagentSourceSessionOf(carriers.body) : source?.taskId;
+    const ownRun = fromSubagent ? subagentSourceSessionOf(carriers.body) : liveRun.taskId;
     const taskId = typeof ownRun === 'string' && ownRun !== '' ? ownRun : undefined;
-    const sessionId = !fromSubagent && typeof source?.sessionId === 'string' && source.sessionId !== '' ? source.sessionId : undefined;
+    const sessionId = fromSubagent ? undefined : liveRun.sessionId;
     const askSig = carrierAskSig(carriers.body, carriers.live);
     return {
         approvalId,
@@ -2033,22 +2376,24 @@ function readApprovalCardClaimSignal(v) {
 export function claimApprovalCard(identity, options) {
     return claimApprovalCardFor(readApprovalHolderIdentity(identity), readApprovalCardClaimSignal(options));
 }
-async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, respond, streamArgs, signal, lane, hold, ledgerSlot, receivedAtMs) {
+async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, respond, streamArgs, signal, lane, hold, ledgerSlot, receivedAtMs, cardTaskId, sourceGeneration) {
     const bodyToolCallId = carriers.body.toolCallId;
     const frameToolCallId = typeof bodyToolCallId === 'string' && bodyToolCallId !== '' ? bodyToolCallId : undefined;
     const decidedByReading = decidedByReadingSnapshotOf(lane);
     const facts = cardFactsOf(carriers.body, carriers.leg, { streamArgs, ...(lane?.argsUnavailable === true ? { argsUnavailable: true } : {}) }, carriers.live, approvalId, carriers.why);
     const argsNotRealInput = facts.argsUnavailable === true;
+    const editAcceptance = editedApprovalAcceptanceOf(facts);
     const ruleOffers = facts.ruleOffers;
-    if (argsNotRealInput && lane?.argsUnavailable !== true && facts.wireNote !== undefined) {
+    if (argsNotRealInput && lane?.argsUnavailable !== true && facts.wireNote !== undefined && facts.inputSource !== 'stream') {
         hostLog('debug', `liveToolApprovalWire: frame ${approvalId} args omitted (>16KiB wire cap) — card falls back to ${Object.hasOwn(facts.args, 'file_path') ? 'the message-derived path' : 'an empty input (no path could be derived from the message)'}`);
     }
-    const card = await surfaceCallTrackedCard(frameToolCallId, approvalId, ledgerSlot, {
-        ...facts,
+    const card = await surfaceCallTrackedCard(frameToolCallId, approvalId, ledgerSlot, cardRequestOf(facts, {
         callKey: liveFrameCallKey(approvalId),
+        ...(cardTaskId !== undefined ? { taskId: cardTaskId } : {}),
+        ...sourceGenerationBit(sourceGeneration),
         signal: hold.cardSignal,
         ...approvalWindowKeysOf(frame, { windowIsCurrent: lane?.windowIsCurrent === true, receivedAtMs, ...(carriers.leg === 'generic' ? { unknownShape: true } : {}) }),
-    });
+    }));
     if (hold.superseded !== undefined) {
         hostLog('debug', `liveToolApprovalWire: ${approvalId} was settled by the engine while its card was up${hold.superseded.parked ? ' (parked)' : ''} — card withdrawn; ` +
             `the card came back ${card.kind}; nothing sent`);
@@ -2056,28 +2401,38 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
             surfaceApprovalParking();
         return { kind: 'not_sent', lane: 'respond', cause: 'retracted' };
     }
-    if (argsNotRealInput && card.kind === 'allow' && card.updatedInput !== undefined) {
+    if (editAcceptance.state !== 'accepts' && card.kind === 'allow' && card.updatedInput !== undefined) {
         hostLog('error', `liveToolApprovalWire: ${approvalId} card returned an edited approval on a card whose arguments are not the tool's real input (${lane?.argsUnavailable === true ? 'args-unavailable ask' : 'arguments omitted or absent on the frame'}) — nothing sent (the ask stays pending)`);
         surfaceEditRefusedOnBlindAsk();
         return { kind: 'not_sent', lane: 'respond', cause: 'edit_refused' };
     }
+    if (card.kind === WITHDRAWN_CARD_DECISION_KIND)
+        return withdrawnCardResolution(card, { lane: 'respond' }, 'liveToolApprovalWire');
     if (card.kind === RETRACTED_CARD_DECISION_KIND) {
         hostLog('debug', `liveToolApprovalWire: ${approvalId} card retracted without a decision${card.reason ? ` (${card.reason})` : ''} — nothing sent`);
         return { kind: 'not_sent', lane: 'respond', cause: 'retracted' };
     }
+    const respondParkingOf = (body) => {
+        const p = readToolApprovalRespondParking(body);
+        return p?.kind === 'parking' ? p.view : undefined;
+    };
+    const deliverOnThisCard = (d, body, carrySignal, deliverySignal, ladder, onLadderStep) => deliverApprovalDecision({
+        approvalId,
+        body,
+        send: (o, sig) => respond(approvalId, d, carrySignal && sig !== undefined ? { ...o, signal: sig } : o),
+        signal: deliverySignal,
+        tally: newSendTally(),
+        ladder,
+        ...(onLadderStep !== undefined ? { onLadderStep } : {}),
+        parkingOf: respondParkingOf,
+    });
     if (card.kind === 'aborted') {
         enterLiveRespondPhase(hold);
         const interruptOpts = lane?.approvalDecisionNoteCapable === true ? { note: INTERRUPT_DENY_REASON } : {};
-        let interruptDeny;
-        try {
-            interruptDeny = Promise.resolve(respond(approvalId, 'deny', interruptOpts));
-        }
-        catch (e) {
-            interruptDeny = Promise.reject(e);
-        }
+        const interruptDeny = deliverOnThisCard('deny', interruptOpts, true, interruptDenyLifetime(), { lastCarried: false, dropped: false, renamed: false }).then((delivery) => (delivery.kind === 'thrown' ? Promise.reject(delivery.error) : delivery.raw));
         hold.trailing = interruptDeny.then((body) => readToolApprovalRespondParking(body) === undefined, () => false);
         observeCancelByDeny(interruptDeny, approvalId);
-        hostLog('debug', `liveToolApprovalWire: ${approvalId} card aborted — one tool-level deny issued to settle the pending ask`);
+        hostLog('debug', `liveToolApprovalWire: ${approvalId} card aborted — a tool-level deny issued to settle the pending ask (bounded retry; at most one is accepted)`);
         return { kind: 'unsettled', lane: 'respond', cause: 'interrupted' };
     }
     enterLiveRespondPhase(hold);
@@ -2094,8 +2449,10 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
             : card;
     const basePayload = answerPayloadFor(answerSnapshot, 'respond', { approvalDecisionNoteCapable: noteCapable });
     const decision = basePayload?.decision ?? 'deny';
-    if (card.kind === 'allow' && typeof card.note === 'string' && card.note.trim() !== '' && answerCarriage({ callKey: liveFrameCallKey(approvalId) }).allowNote === 'none') {
-        hostLog('debug', `liveToolApprovalWire: ${approvalId} card carried a note on Yes (len=${card.note.length}) — this engine has no field that brings it to the model, so it was not sent`);
+    const allowNoteText = decision !== 'deny' ? allowNoteReadingOf(answerSnapshot) : { kind: 'absent' };
+    const allowNoteDropped = allowNoteText.kind === 'text' && answerCarriage({ callKey: liveFrameCallKey(approvalId) }).allowNote === 'none';
+    if (allowNoteDropped && allowNoteText.kind === 'text') {
+        hostLog('debug', `liveToolApprovalWire: ${approvalId} card carried a note on Yes (len=${allowNoteText.text.length}) — this approval door has no field that brings it to the model, so it was not sent`);
     }
     const denySettledByForWire = card.kind === 'deny' ? readApprovalDenySettledBy(card) : undefined;
     const denyPolicyCauseForWire = card.kind === 'deny' ? readPolicyDenyCause(card) : undefined;
@@ -2198,30 +2555,18 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
         if (basePayload !== undefined)
             emitAnswerCommitted(liveFrameCallKey(approvalId), 'respond', answerSnapshot, basePayload);
         try {
-            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 ' +
+            const delivery = await deliverOnThisCard(decision, respondOpts, !signalPreAborted, 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 ' +
                             '(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;
-                },
+                        : `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)');
             });
             if (delivery.kind === 'thrown') {
                 deliveryFailure = delivery;
@@ -2249,16 +2594,14 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
                 'reporting the answer as NOT settled (never as decided, never as parked); not re-sent');
             return { kind: 'unsettled', lane: 'respond', cause: 'unreadable' };
         }
-        const parsed = readToolApprovalRespondAck(raw);
-        const replayedForThisCard = parsed !== undefined && isToolApprovalRespondReplayed(parsed) && parsed.approvalId === approvalId;
-        const claimsReplay = ownIdempotentTrue(raw) || (parsed !== undefined && isToolApprovalRespondReplayed(parsed));
-        if (claimsReplay && !replayedForThisCard) {
-            const claimed = replayClaimOf(raw);
-            if (claimed.approvalId === approvalId && claimed.decision !== undefined && !claimed.carriesDelivery) {
-                hostLog('debug', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered with a replay (body not in the full replay shape) — the approval was already decided ` +
-                    `(${claimed.decision}); this answer was not delivered, reporting the earlier decision`);
-                return { kind: 'decided', lane: 'respond', decision: claimed.decision };
-            }
+        const parsed = settlementAckOf(readToolApprovalRespondAck(raw));
+        const replayVerdict = replayVerdictFrom(raw, parsed, approvalId);
+        if (replayVerdict.kind === 'replayed' && replayVerdict.via === 'claim') {
+            hostLog('debug', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered with a replay (body not in the full replay shape) — the approval was already decided ` +
+                `(${replayVerdict.firstDecision}); this answer was not delivered, reporting the earlier decision`);
+            return replayedDecisionOf(replayVerdict.firstDecision, decision, parsed !== undefined && isToolApprovalRespondParkedRedeemed(parsed) && parsed.approvalId === approvalId ? parsed : undefined);
+        }
+        if (replayVerdict.kind === 'unreadable') {
             hostLog('error', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered with a replay of an earlier decision that cannot be read or names another approval — ` +
                 'reporting the answer as NOT settled (never as the decision this client sent); not re-sent');
             return { kind: 'unsettled', lane: 'respond', cause: 'unreadable' };
@@ -2327,6 +2670,8 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
         }
         if (replayed === undefined && sessionDowngraded)
             surfaceRememberNotApplied();
+        if (replayed === undefined && allowNoteDropped)
+            surfaceAllowNoteNotCarried(allowNoteNotCarriedSentence());
         if (respondOpts.updatedInput !== undefined && applied?.updatedInputForwarded === false) {
             logAfterDecided(`liveToolApprovalWire: ${approvalId} edited args were NOT forwarded (ack.updatedInputForwarded=false) — the tool runs on the ORIGINAL input`);
             surfaceEditNotForwarded();
@@ -2338,7 +2683,7 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
         if (replayed !== undefined) {
             hostLog('debug', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered with a replay — the approval was already decided (${replayed.decision}); ` +
                 'this answer was not delivered, reporting the earlier decision');
-            return { kind: 'decided', lane: 'respond', decision: replayed.decision, ack: replayed };
+            return replayedDecisionOf(replayed.decision, decision, replayed);
         }
         const deny = decision === 'deny' ? denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed, denyPolicyCauseForWire) : undefined;
         return { kind: 'decided', lane: 'respond', decision, ...(ack !== undefined ? { ack } : {}), ...(deny !== undefined ? { deny } : {}) };