@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/hitl/toolApprovalWire.js

@@ -4,7 +4,7 @@ import { parkGateArmOf } from './frameRouter.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, approvalRequestedByOf } from './approvalAskers.js';
@@ -17,7 +17,7 @@ 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, surfaceAllowNoteNotCarried, 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';
@@ -39,6 +39,7 @@ 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();
@@ -110,10 +111,9 @@ function withdrawnCardResolution(card, at, logTag) {
     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(taskId, row, gatedCallId) {
+function parkRowOf(row, gatedCallId) {
     const d = parkRowDeadlineState(row, Date.now());
     return Object.freeze({
-        taskId,
         ...(gatedCallId !== undefined && gatedCallId !== '' ? { gatedCallId } : {}),
         ...(d.kind !== 'none' ? { deadlineMs: d.deadlineMs } : {}),
     });
@@ -225,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;
@@ -472,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;
@@ -501,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;
     });
@@ -515,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 : '';
@@ -548,7 +547,7 @@ 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 } : {}),
@@ -571,8 +570,9 @@ 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);
@@ -580,7 +580,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     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 };
@@ -595,7 +595,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 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);
                 }
@@ -919,14 +919,14 @@ const ANSWER_CARRIAGE_MODEL = Object.freeze({ allowNote: 'model' });
 export function answerCarriage(card) {
     return cardIsOnParkRow(card) ? ANSWER_CARRIAGE_MODEL : ANSWER_CARRIAGE_NONE;
 }
-function cardIsOnParkRow(card) {
+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(park, 'taskId') !== undefined;
+        return readOwnDataNonEmptyString(card, 'taskId') !== undefined;
     }
     catch {
         return false;
@@ -970,35 +970,43 @@ export function settlementAckOf(read) {
 export function readToolApprovalRespondAck(v) {
     if (v === null || typeof v !== 'object')
         return undefined;
-    const o = v;
-    const accepted = slotReadOf(o, 'accepted');
-    if (accepted.presence === 'present' && accepted.value === 'parked_redeemed')
-        return readParkedRedeemedAck(o);
-    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;
@@ -1019,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;
@@ -1061,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;
@@ -1072,65 +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(o) {
-    if (slotReadOf(o, 'delivery').presence !== 'absent')
+function readParkedRedeemedAck(s) {
+    if (s.delivery.presence !== 'absent')
         return undefined;
-    const text = (key) => {
-        const slot = slotReadOf(o, key);
-        return slot.presence === 'present' && typeof slot.value === 'string' && slot.value !== '' ? slot.value : undefined;
+    const text = (slot) => {
+        const v = slotValueOf(slot);
+        return typeof v === 'string' && v !== '' ? v : undefined;
     };
-    const approvalId = text('approvalId');
-    const askId = text('askId');
+    const approvalId = text(s.approvalId);
+    const askId = text(s.askId);
     if (approvalId === undefined || askId === undefined)
         return undefined;
-    const idem = slotReadOf(o, 'idempotent');
-    if (idem.presence === 'unreadable')
-        return undefined;
-    const replay = idem.presence === 'present' && idem.value === true;
-    const dec = slotReadOf(o, 'decision');
+    const replay = slotValueOf(s.idempotent) === true;
+    const dec = slotValueOf(s.decision);
     let decision;
     if (replay) {
-        if (dec.presence !== 'present' || (dec.value !== 'allow' && dec.value !== 'deny'))
+        if (dec !== 'allow' && dec !== 'deny')
             return undefined;
-        decision = dec.value === 'allow' ? 'allow' : 'deny';
+        decision = dec;
     }
     else {
-        decision = dec.presence === 'present' && typeof dec.value === 'string' && dec.value !== '' ? dec.value : undefined;
+        decision = typeof dec === 'string' && dec !== '' ? dec : undefined;
     }
-    const remember = slotReadOf(o, 'rememberApplied');
+    const remember = slotValueOf(s.rememberApplied);
     return {
         approvalId,
         askId,
         accepted: 'parked_redeemed',
         ...(replay ? { idempotent: true } : {}),
         ...(decision !== undefined ? { decision } : {}),
-        ...(remember.presence === 'present' && typeof remember.value === 'boolean' ? { rememberApplied: remember.value } : {}),
+        ...(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)
@@ -1854,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();
@@ -1899,7 +2046,7 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
             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, ...inputSourceBitOf(reading) };
+                return { args: reading.args, ...argsFromModelCallBitsOf(), ...inputSourceBitOf(reading) };
             }
             const omitted = c.argsOmitted === true || reading.shape === 'size_marker';
             const fallback = argsFallbackOf(c.message, omitted);
@@ -2117,7 +2264,9 @@ export async function surfaceApprovalFrameWithId(frame, approvalId, respond, str
         return approvalIdUnreadableRefusal();
     const carriers = openingFrameCarriersOf(frame);
     const liveRun = liveCardRunOf(frame, run);
-    const entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, carriers, liveRun), respond, streamArgs, signal, lane, receivedAtMs };
+    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) {
@@ -2143,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, e.identity.taskId);
+        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;
     });
@@ -2227,7 +2376,7 @@ 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, cardTaskId) {
+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);
@@ -2235,16 +2384,16 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
     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`);
@@ -2263,19 +2412,27 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
         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);
@@ -2398,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;
@@ -2450,15 +2595,13 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
             return { kind: 'unsettled', lane: 'respond', cause: 'unreadable' };
         }
         const parsed = settlementAckOf(readToolApprovalRespondAck(raw));
-        const replayedForThisCard = parsed !== undefined && isToolApprovalRespondReplayed(parsed) && parsed.approvalId === approvalId;
-        const claimsReplay = ownIdempotentTrue(raw) || replayedFirstDecisionOf(parsed) !== undefined;
-        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 replayedDecisionOf(claimed.decision, decision, parsed !== undefined && isToolApprovalRespondParkedRedeemed(parsed) && parsed.approvalId === approvalId ? parsed : undefined);
-            }
+        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' };

package/dist/hooksReaderGenerations.js

@@ -1,6 +1,6 @@
 import { engineVersionTier } from './supportFloor.js';
 const HOOKS_READER_GENERATIONS = Object.freeze([
-    Object.freeze({ from: '7.139.0', below: '7.147.0', notRead: Object.freeze(['onFailure']) }),
+    Object.freeze({ from: '7.139.0', below: '7.147.0', notRead: Object.freeze(['onFailure', 'rewakeMessage', 'rewakeSummary', 'cloud', 'continueOnBlock']) }),
 ]);
 const HOOKS_READER_FAIL_CLOSED = Object.freeze([...new Set(HOOKS_READER_GENERATIONS.flatMap((g) => g.notRead))]);
 export function hooksReaderNotReadKeys(serverVersion) {