@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/hitl/toolApprovalWire.js

@@ -1,18 +1,22 @@
-import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, denyReasonForWire, findPendingForTask, hitlSafetyCodeOf, readDecideCurrentPending, readWireErrorCode, readWireErrorCodeReading, } from './hitlBridge.js';
 import { askParkRowArm } from './askParkRowRouting.js';
 import { hostLog } from '../host.js';
-import { readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
+import { readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPair } from './askClassPair.js';
-import { legacyShadowedRuleTextOf, readAllowRuleShadowFromWire } from './allowRuleShadow.js';
+import { readAllowRuleShadowFromWire } from './allowRuleShadow.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
-import { observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
+import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
+import { displayUntrusted } from '../displayUntrusted.js';
+import { approvalDecisionHolds, awaitLiveCardHolder, holdLiveCard, joinLiveCard, liveCardHoldFor, liveCardHoldOf } from './approvalHolds.js';
+import { approvalResolutionOf } from './approvalResolution.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
-import { refusalSaysStillPending } from '../engineErrorCodes.js';
+import { thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, refusalSaysStillPending } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, PERSISTED_RULE_MANDATES, } from '@sema-agent/sdk';
 export function isFsApprovalGate(gate) {
@@ -110,6 +114,7 @@ export function approvalCardPortFor(sessionKey) {
 export function _resetApprovalCardPortForTest() {
     cardPortByKey.clear();
     cardPortMissesByKey.clear();
+    callCardLedger.clear();
 }
 export function surfaceApprovalCard(req) {
     const cardPort = approvalCardPortFor(DEFAULT_SESSION_KEY);
@@ -127,17 +132,26 @@ function cardPortMissReason() {
         return APPROVAL_CARD_PORT_KEY_MISMATCH_REASON;
     return NO_APPROVAL_CARD_PORT_REASON;
 }
-function rememberRefusedByServer(e) {
-    switch (readWireErrorCode(e)) {
-        case 'remember_not_in_proof':
-        case 'remember_requires_binding':
-        case 'capability.store_required':
-        case 'decide.workflow_remember_unsupported':
-        case 'decide.parked_remember_unsupported':
-            return true;
-        default:
-            return false;
-    }
+const REMEMBER_REFUSAL_CODES = Object.freeze([
+    'remember_not_in_proof',
+    'remember_requires_binding',
+    'capability.store_required',
+    DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
+    'decide.parked_remember_unsupported',
+]);
+export function rememberRefusalOf(error) {
+    return rememberRefusalIn(readWireErrorCodeReading(error));
+}
+function rememberRefusalIn(reading) {
+    return reading.state === 'code' ? REMEMBER_REFUSAL_CODES.find((c) => c === reading.code) : undefined;
+}
+function rememberFallbackKind(e) {
+    const reading = readWireErrorCodeReading(e);
+    if (rememberRefusalIn(reading) !== undefined)
+        return 'refused';
+    if (reading.state !== 'absent')
+        return undefined;
+    return readToolApprovalRespondRefusal(e)?.status === 400 ? 'legacy' : undefined;
 }
 function logAfterDecided(msg) {
     try {
@@ -170,17 +184,17 @@ function isParkRowInputSizeMarker(v) {
     const o = v;
     return o.truncated === true && typeof o.bytes === 'number' && Number.isFinite(o.bytes) && o.bytes >= 0;
 }
-const durableDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), clock: 0 };
 function durableHoldKey(row, callKey) {
-    return JSON.stringify([typeof row.sessionId === 'string' ? row.sessionId : null, typeof row.taskId === 'string' ? row.taskId : null, callKey]);
+    const createdAt = typeof row.createdAt === 'number' && Number.isFinite(row.createdAt) ? row.createdAt : null;
+    return JSON.stringify([typeof row.sessionId === 'string' ? row.sessionId : null, typeof row.taskId === 'string' ? row.taskId : null, callKey, createdAt]);
 }
 function openDurableRead() {
-    const mark = ++durableDecisionHolds.clock;
-    durableDecisionHolds.openReads.add(mark);
+    const mark = ++approvalDecisionHolds.clock;
+    approvalDecisionHolds.openReads.add(mark);
     return mark;
 }
 function closeDurableRead(mark) {
-    const h = durableDecisionHolds;
+    const h = approvalDecisionHolds;
     h.openReads.delete(mark);
     let oldest = Infinity;
     for (const m of h.openReads)
@@ -191,14 +205,14 @@ function closeDurableRead(mark) {
             h.settled.delete(key);
 }
 function heldDurableDecision(holdKey, readMark) {
-    const live = durableDecisionHolds.inFlight.get(holdKey);
+    const live = approvalDecisionHolds.inFlight.get(holdKey);
     if (live !== undefined)
-        return live;
-    const recent = durableDecisionHolds.settled.get(holdKey);
+        return live.lane === 'durable' ? live : undefined;
+    const recent = approvalDecisionHolds.settled.get(holdKey);
     return recent !== undefined && recent.at > readMark ? recent.hold : undefined;
 }
 function holdDurableDecision(holdKey, callerSignal, decide) {
-    const h = durableDecisionHolds;
+    const h = approvalDecisionHolds;
     const interruption = new AbortController();
     let settled = false;
     const interrupt = () => {
@@ -215,7 +229,7 @@ function holdDurableDecision(holdKey, callerSignal, decide) {
         resolveOutcome = resolve;
         rejectOutcome = reject;
     });
-    const hold = { outcome, presented: false, interrupt, cardSignal: interruption.signal };
+    const hold = { lane: 'durable', outcome, presented: false, interrupt, cardSignal: interruption.signal };
     h.inFlight.set(holdKey, hold);
     const release = () => {
         if (h.inFlight.get(holdKey) === hold)
@@ -276,11 +290,50 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         return { kind: 'failed', stage: 'fetch', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
     if (held !== undefined)
         return joinDurableDecision(held, deps, signal);
+    const liveHolder = liveCardHoldFor(parkRowHolderIdentity(found.pending, found.gatedCallId));
+    if (liveHolder !== undefined) {
+        const joined = await awaitLiveCardHolder(liveHolder, signal);
+        if (joined !== undefined)
+            return fsOutcomeOfJoinedLiveCard(joined, found.gatedCallId);
+        return surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signal, parkGatedCallId);
+    }
     const callKey = approvalCallKey(found.gatedCallId, taskId);
     const fetched = found;
-    return holdDurableDecision(durableHoldKey(fetched.pending, callKey), signal, (hold) => presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, fetched, decidedByReading, callKey, hold));
+    return holdDurableDecision(durableHoldKey(fetched.pending, callKey), signal, async (hold) => {
+        const slot = {};
+        const out = await presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, fetched, decidedByReading, callKey, hold, slot);
+        noteCallOutcome(slot, out);
+        return out;
+    });
 }
-async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, found, decidedByReading, callKey, hold) {
+function parkRowHolderIdentity(row, gatedCallId) {
+    return {
+        ...(typeof row.taskId === 'string' && row.taskId !== '' ? { taskId: row.taskId } : {}),
+        ...(gatedCallId !== undefined && gatedCallId !== '' ? { toolCallId: gatedCallId } : {}),
+        ...(typeof row.sessionId === 'string' && row.sessionId !== '' ? { sessionId: row.sessionId } : {}),
+    };
+}
+function fsOutcomeOfJoinedLiveCard(o, gatedCallId) {
+    if (o.aborted === true)
+        return { kind: 'aborted', gatedCallId, joinedInFlight: true };
+    if (o.decision === 'unresolved')
+        return { kind: 'retracted', gatedCallId, joinedInFlight: true };
+    return {
+        kind: 'decided',
+        gatedCallId,
+        ...(o.decision === 'deny'
+            ? {
+                denied: true,
+                ...(o.denySettledBy !== undefined ? { denySettledBy: o.denySettledBy } : {}),
+                ...(o.denyReason !== undefined ? { denyReason: o.denyReason } : {}),
+            }
+            : {}),
+        ...(o.denyAttributionDropped === true ? { denyAttributionDropped: true } : {}),
+        ...(o.denyAttributionRenamed === true ? { denyAttributionRenamed: true } : {}),
+        joinedInFlight: true,
+    };
+}
+async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, found, decidedByReading, callKey, hold, ledgerSlot) {
     const { pending, gatedCallId } = found;
     const toolName = typeof pending.toolName === 'string' ? pending.toolName : '';
     const streamArgs = gatedCallId !== undefined ? argsByCall.get(gatedCallId) : undefined;
@@ -304,7 +357,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     const durableRuleOffersAbsence = pending.ruleOffersAbsence;
     hold.presented = true;
     deps.onPresented?.();
-    const card = await surfaceApprovalCard({
+    const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, {
         toolName,
         args,
         callKey,
@@ -319,16 +372,15 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
         ...(pending.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
         ...(hasOwnStrictTrue(pending, 'mandated') ? { mandated: true } : {}),
         ...((w) => (w !== undefined ? { mandate: w } : {}))(readApprovalMandate(pending)),
-        ...((o) => (o !== undefined ? { origin: o } : {}))(readOwnNonEmptyString(pending, 'origin')),
+        ...((o) => (o !== undefined ? { origin: o } : {}))(readAskOrigin(pending)),
         ...(readAskClassPair(pending) ?? {}),
         ...(pending.gateKind === 'irreversible_ask' ? { irreversibleParkGate: true } : {}),
         ...(pending.hasBidiControls === true ? { hasBidiControls: true } : {}),
         ...(ruleOffersReadOnly !== undefined ? { ruleOffersReadOnly } : {}),
         ...(isWireRecordCarrier(durableProbeCause) ? { probeCause: durableProbeCause } : {}),
         ...(durableProbeReason !== undefined ? { probeReason: durableProbeReason } : {}),
-        ...(readRememberRefused(pending) ? { rememberRefused: true } : {}),
+        ...(readApprovalRememberRefused(pending) ? { rememberRefused: true } : {}),
         ...(durableShadow !== undefined ? { allowRuleShadow: durableShadow } : {}),
-        ...((t) => (t !== undefined ? { persistedRuleShadowed: t } : {}))(legacyShadowedRuleTextOf(durableShadow)),
         ...(typeof durableRuleOffersAbsence === 'string' && durableRuleOffersAbsence !== ''
             ? { ruleOffersAbsence: durableRuleOffersAbsence }
             : {}),
@@ -352,7 +404,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 return { kind: 'retracted', gatedCallId };
             case 'aborted':
                 {
-                    const cancelDeny = bridge.decideTool({ decision: 'deny', reason: 'Interrupted by user' }, gatedCallId, undefined, pending);
+                    const cancelDeny = bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, undefined, pending);
                     hold.trailing = cancelDeny;
                     observeCancelByDeny(cancelDeny, taskId);
                 }
@@ -369,12 +421,11 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                             sessionDecided = true;
                         }
                         catch (e) {
-                            if (e instanceof HitlSafetyError || e instanceof DecideTransportRetryExhaustedError)
+                            const fallbackKind = rememberFallbackKind(e);
+                            if (fallbackKind === undefined)
                                 throw e;
-                            if (readDecideCurrentPending(e) !== undefined)
-                                throw e;
-                            rememberRefused = rememberRefusedByServer(e);
-                            logAfterDecided(`liveToolApprovalWire: decide(approve+remember) failed (${String(e)}) — falling back to plain approve`);
+                            rememberRefused = fallbackKind === 'refused';
+                            logAfterDecided(`liveToolApprovalWire: decide(approve+remember) refused the remember part (${String(e)}) — falling back to plain approve`);
                         }
                         if (sessionDecided) {
                             if (sessionReceipt?.rememberApplied === false)
@@ -392,13 +443,15 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const currentPending = readDecideCurrentPending(e);
                     const wireCode = readWireErrorCode(e);
                     const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
-                    const safetyCode = e instanceof HitlSafetyError ? e.code : undefined;
+                    const safetyCode = hitlSafetyCodeOf(e);
+                    const failureTexts = wireFailureTextsOf(e);
+                    hostLog('debug', `liveToolApprovalWire: decide(approve) failed: ${failureTexts.log}`);
                     return {
                         kind: 'failed',
                         stage: 'decide',
                         gatedCallId,
-                        reason: `decide(approve) failed: ${String(e)}${decideFailureNote(e, 'approve')}`,
-                        ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                        reason: `decide(approve) failed: ${failureTexts.reason}${decideFailureNote(e, 'approve')}`,
+                        ...(thrownIsInstanceOf(e, DecideTransportRetryExhaustedError) ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
                         ...(wireRetriable ? { retriable: true } : {}),
@@ -476,14 +529,16 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const currentPending = readDecideCurrentPending(e);
                     const wireCode = readWireErrorCode(e);
                     const wireRetriable = typeof e === 'object' && e !== null && refusalSaysStillPending(e);
-                    const safetyCode = e instanceof HitlSafetyError ? e.code : undefined;
+                    const safetyCode = hitlSafetyCodeOf(e);
                     const attributionRefusal = denyAttributionRefusalFromError(e, lastSendCarriedAttribution);
+                    const failureTexts = wireFailureTextsOf(e);
+                    hostLog('debug', `liveToolApprovalWire: decide(deny) failed: ${failureTexts.log}`);
                     return {
                         kind: 'failed',
                         stage: 'decide',
                         gatedCallId,
-                        reason: `decide(deny) failed: ${String(e)}${decideFailureNote(e, 'deny')}`,
-                        ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
+                        reason: `decide(deny) failed: ${failureTexts.reason}${decideFailureNote(e, 'deny')}`,
+                        ...(thrownIsInstanceOf(e, DecideTransportRetryExhaustedError) ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
                         ...(wireRetriable ? { retriable: true } : {}),
@@ -548,6 +603,7 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'serverNowMs',
     'delegation',
     'outcome',
+    'cause',
 ];
 const _mirrorPin = [true, true];
 void _mirrorPin;
@@ -574,7 +630,7 @@ export function toolPermissionRequestAskBits(card) {
         return {};
     const mandated = hasOwnStrictTrue(card, 'mandated');
     const mandate = readApprovalMandate(card);
-    const origin = readOwnNonEmptyString(card, 'origin');
+    const origin = readAskOrigin(card);
     const ruleOffersAbsence = readOwnNonEmptyString(card, 'ruleOffersAbsence');
     const askClassPair = readAskClassPair(card);
     return {
@@ -656,7 +712,7 @@ export function readToolApprovalRespondAck(v) {
     }
     return out;
 }
-function readToolApprovalRespondParking(v) {
+export function readToolApprovalRespondParking(v) {
     if (typeof v !== 'object' || v === null)
         return undefined;
     const read = (fn) => {
@@ -675,7 +731,16 @@ function readToolApprovalRespondParking(v) {
     const hint = read(() => readOwnDataValue(v, 'retryAfterMs'));
     const retryAfterMs = typeof hint === 'number' && Number.isFinite(hint) && hint >= 0 ? hint : undefined;
     const decidePath = read(() => readOwnDataNonEmptyString(v, 'decidePath'));
-    return { kind: 'parking', view: { approvalId, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), ...(decidePath !== undefined ? { decidePath } : {}) } };
+    const message = read(() => readOwnDataNonEmptyString(v, 'message'));
+    return {
+        kind: 'parking',
+        view: {
+            approvalId,
+            ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+            ...(decidePath !== undefined ? { decidePath } : {}),
+            ...(message !== undefined ? { message } : {}),
+        },
+    };
 }
 function isNonEmptyStringArray(v) {
     return Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string' && x !== '');
@@ -830,14 +895,28 @@ function readProbeReason(v) {
     try {
         if (typeof v !== 'object' || v === null || !Object.hasOwn(v, 'probeReason'))
             return undefined;
-        const raw = v.probeReason;
-        return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
+        return usableProbeReason(v.probeReason);
     }
     catch {
         return undefined;
     }
 }
-function readRememberRefused(v) {
+function usableProbeReason(raw) {
+    return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
+}
+const PROBE_CAUSE_CODE_WORD = /^[a-z][a-z0-9_]{0,31}(?:\.[a-z][a-z0-9_]{0,31}){1,3}$/;
+export function askProbeReasonDetail(card) {
+    const reason = usableProbeReason(ownDataValue(card, 'probeReason'));
+    if (reason !== undefined)
+        return displayUntrusted(reason);
+    const cause = ownDataValue(card, 'probeCause');
+    if (!isWireRecordCarrier(cause))
+        return undefined;
+    const code = ownDataValue(cause, 'code');
+    const head = 'An automatic check could not clear this call, so it is asking you; the engine did not say the specific reason';
+    return typeof code === 'string' && PROBE_CAUSE_CODE_WORD.test(code) ? `${head} (check code: ${code}).` : `${head}.`;
+}
+export function readApprovalRememberRefused(v) {
     try {
         return typeof v === 'object' && v !== null && Object.hasOwn(v, 'rememberRefused') && v.rememberRefused === true;
     }
@@ -845,6 +924,167 @@ function readRememberRefused(v) {
         return false;
     }
 }
+function ownDataValue(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ownStringList(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    try {
+        const length = v.length;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < length; i++) {
+            const d = Object.getOwnPropertyDescriptor(v, i);
+            if (d === undefined || !('value' in d) || typeof d.value !== 'string' || d.value === '')
+                return undefined;
+            out.push(d.value);
+        }
+        return v.length === length ? Object.freeze(out) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readApprovalBoundGrants(v) {
+    const g = ownDataValue(v, 'boundGrants');
+    if (typeof g !== 'object' || g === null || Array.isArray(g))
+        return undefined;
+    const skill = ownDataValue(g, 'skill');
+    if (!(skill === null || (typeof skill === 'string' && skill !== '')))
+        return undefined;
+    const allowedTools = ownStringList(ownDataValue(g, 'allowedTools'));
+    const disallowedTools = ownStringList(ownDataValue(g, 'disallowedTools'));
+    if (allowedTools === undefined || disallowedTools === undefined)
+        return undefined;
+    return Object.freeze({ skill, allowedTools, disallowedTools });
+}
+const CAUSE_WORD = /^[a-z][a-z0-9_]{0,63}$/;
+export function readApprovalClassifierNoRuling(v) {
+    const w = ownDataValue(v, 'classifierNoRuling');
+    return typeof w === 'string' && CAUSE_WORD.test(w) ? w : undefined;
+}
+const CLASSIFIER_NO_RULING_REASONS = Object.freeze({
+    error: 'could not run for this call (it failed)',
+    timeout: 'could not run for this call (it timed out)',
+    parse_error: 'answered for this call but gave no verdict it could use',
+});
+const _noRulingPin = [true, true];
+void _noRulingPin;
+export function classifierNoRulingDetail(word) {
+    if (typeof word === 'string' && Object.hasOwn(CLASSIFIER_NO_RULING_REASONS, word)) {
+        return `The auto-mode classifier ${CLASSIFIER_NO_RULING_REASONS[word]}, so it is asking you instead.`;
+    }
+    if (typeof word === 'string' && CAUSE_WORD.test(word))
+        return `The auto-mode classifier did not rule on this call (reason: ${word}), so it is asking you instead.`;
+    return 'The auto-mode classifier did not rule on this call, so it is asking you instead.';
+}
+const entries = (n) => (n === 1 ? '1 tool entry' : `${String(n)} tool entries`);
+export function approvalBoundGrantsDetail(grants) {
+    const g = readApprovalBoundGrants({ boundGrants: grants });
+    if (g === undefined)
+        return undefined;
+    if (g.skill === null)
+        return 'This call names no loaded skill, so approving it grants nothing beyond this call.';
+    const a = g.allowedTools.length;
+    const d = g.disallowedTools.length;
+    if (a === 0 && d === 0)
+        return 'Approving this activates the skill shown on the card; it lists no tools to run without asking and none to refuse.';
+    const allow = `${entries(a)} it lists ${a === 1 ? 'runs' : 'run'} without asking once it is active`;
+    const deny = `${entries(d)} ${d === 1 ? 'is' : 'are'} refused for the rest of this run`;
+    return `Approving this activates the skill shown on the card: ${allow}, and ${deny}.`;
+}
+const CALL_LEDGER_MAX_CALLS = 256;
+const CALL_LEDGER_MAX_ASKS_PER_CALL = 8;
+const callCardLedger = new Map();
+function askSignatureOf(req) {
+    return JSON.stringify([req.classes !== undefined ? [...req.classes] : null, req.origin ?? null, req.mandate ?? null]);
+}
+function priorCardView(a) {
+    return Object.freeze({
+        ...(a.approvalId !== undefined ? { approvalId: a.approvalId } : {}),
+        ...(a.origin !== undefined ? { origin: a.origin } : {}),
+        ...(a.mandate !== undefined ? { mandate: a.mandate } : {}),
+        ...(a.outcome !== undefined ? { outcome: a.outcome } : {}),
+    });
+}
+function noteCardOnCall(callId, approvalId, req) {
+    const sig = askSignatureOf(req);
+    let asks = callCardLedger.get(callId);
+    if (asks === undefined) {
+        asks = [];
+        callCardLedger.set(callId, asks);
+        while (callCardLedger.size > CALL_LEDGER_MAX_CALLS) {
+            const oldest = callCardLedger.keys().next().value;
+            if (oldest === undefined)
+                break;
+            callCardLedger.delete(oldest);
+        }
+    }
+    let at = asks.findIndex((a) => a.sig === sig);
+    if (at < 0) {
+        asks.push({ sig, ...(approvalId !== undefined ? { approvalId } : {}), ...(req.origin !== undefined ? { origin: req.origin } : {}), ...(req.mandate !== undefined ? { mandate: req.mandate } : {}) });
+        while (asks.length > CALL_LEDGER_MAX_ASKS_PER_CALL)
+            asks.shift();
+        at = asks.length - 1;
+    }
+    else if (asks[at].approvalId === undefined && approvalId !== undefined) {
+        asks[at].approvalId = approvalId;
+    }
+    const entry = asks[at];
+    const prior = asks.slice(0, at);
+    return { entry, ...(prior.length > 0 ? { prior: Object.freeze(prior.map(priorCardView)) } : {}) };
+}
+async function surfaceCallTrackedCard(callId, approvalId, slot, req) {
+    if (callId === undefined || callId === '')
+        return surfaceApprovalCard(req);
+    const { entry, prior } = noteCardOnCall(callId, approvalId, req);
+    slot.entry = entry;
+    return surfaceApprovalCard(prior !== undefined ? { ...req, priorCardsForCall: prior } : req);
+}
+function noteCallOutcome(slot, outcome) {
+    const entry = slot.entry;
+    if (entry === undefined)
+        return;
+    const r = approvalResolutionOf(outcome);
+    if (r.kind === 'decided')
+        entry.outcome = r.decision === 'deny' ? 'denied' : 'allowed';
+}
+export function approvalPriorCardsDetail(card) {
+    const prior = ownDataValue(card, 'priorCardsForCall');
+    let isList = false;
+    try {
+        isList = Array.isArray(prior);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isList)
+        return undefined;
+    const length = ownDataValue(prior, 'length');
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length <= 0 || length > CALL_LEDGER_MAX_ASKS_PER_CALL)
+        return undefined;
+    const items = [];
+    for (let i = 0; i < length; i++)
+        items.push(ownDataValue(prior, String(i)));
+    const outcome = ownDataValue(items[length - 1], 'outcome');
+    const earlier = outcome === 'allowed' ? 'you already approved an earlier one' : outcome === 'denied' ? 'an earlier one was denied' : 'an earlier one was shown first';
+    const fromRule = items.some((p) => ownDataValue(p, 'origin') === 'ask_rule');
+    const thisFromRule = ownDataValue(card, 'origin') === 'ask_rule';
+    if (fromRule && !thisFromRule) {
+        return `This is a second approval for the same call: ${earlier}, which your ask rule asked for. This one is a separate check, not from your ask rule, and needs its own answer.`;
+    }
+    return `This is a second approval for the same call: ${earlier}. This one is a separate check and needs its own answer.`;
+}
 function isNonNegativeFinite(v) {
     return typeof v === 'number' && Number.isFinite(v) && v >= 0;
 }
@@ -1010,8 +1250,56 @@ function subagentBadgeFor(frame) {
     return { name, color: 'cyan' };
 }
 const MAX_RESPOND_NOTE_CHARS = 2048;
-export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane) {
+export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane, run) {
     const approvalId = frame.approvalId;
+    const held = liveCardHoldOf(liveFrameCallKey(approvalId));
+    if (held !== undefined)
+        return joinLiveCard(held, signal);
+    return holdLiveCard(liveCardIdentityOf(approvalId, frame, run), signal, async (hold) => {
+        const slot = {};
+        const out = await presentToolApprovalFrameAndRespond(frame, approvalId, respond, streamArgs, signal, lane, hold, slot);
+        noteCallOutcome(slot, out);
+        return out;
+    });
+}
+function liveCardIdentityOf(approvalId, frame, run) {
+    const toolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;
+    const fromSubagent = isFromSubagent(frame);
+    const ownRun = fromSubagent ? frame.sourceTaskId : run?.taskId;
+    const taskId = typeof ownRun === 'string' && ownRun !== '' ? ownRun : undefined;
+    const sessionId = !fromSubagent && typeof run?.sessionId === 'string' && run.sessionId !== '' ? run.sessionId : undefined;
+    return {
+        approvalId,
+        ...(toolCallId !== undefined ? { toolCallId } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(sessionId !== undefined ? { sessionId } : {}),
+    };
+}
+function readApprovalHolderIdentity(v) {
+    if (typeof v !== 'object' || v === null)
+        return {};
+    const out = {};
+    try {
+        for (const k of ['approvalId', 'taskId', 'toolCallId', 'sessionId']) {
+            const d = Object.getOwnPropertyDescriptor(v, k);
+            const x = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+            if (typeof x === 'string' && x !== '')
+                out[k] = x;
+        }
+    }
+    catch {
+        return {};
+    }
+    return out;
+}
+export async function joinApprovalHolder(identity, signal) {
+    const hold = liveCardHoldFor(readApprovalHolderIdentity(identity));
+    if (hold === undefined)
+        return { kind: 'free' };
+    const joined = await awaitLiveCardHolder(hold, signal);
+    return joined !== undefined ? { kind: 'joined', outcome: joined } : { kind: 'free' };
+}
+async function presentToolApprovalFrameAndRespond(frame, approvalId, respond, streamArgs, signal, lane, hold, ledgerSlot) {
     const frameToolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;
     const decidedByReading = decidedByReadingSnapshotOf(lane);
     const toolName = typeof frame.toolName === 'string' ? frame.toolName : 'Write';
@@ -1041,14 +1329,14 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
     const ruleOffers = readRuleOffers(frame.ruleOffers);
     const denialLimitFallback = readDenialLimitFallback(frame.denialLimitFallback);
     const frameShadow = readAllowRuleShadowFromWire(frame, 'frame');
-    const card = await surfaceApprovalCard({
+    const card = await surfaceCallTrackedCard(frameToolCallId, approvalId, ledgerSlot, {
         toolName,
         args: args,
         callKey: liveFrameCallKey(approvalId),
         ...(frameToolCallId !== undefined
             ? { toolCallId: frameToolCallId }
             : {}),
-        ...(signal ? { signal } : {}),
+        signal: hold.cardSignal,
         ...(isFromSubagent(frame) ? { workerBadge: subagentBadgeFor(frame) } : {}),
         ...(wireNote !== undefined ? { wireNote } : {}),
         ...(argsNotRealInput ? { argsUnavailable: true } : {}),
@@ -1068,10 +1356,9 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             : {}),
         ...(ruleOffers !== undefined ? { ruleOffers } : {}),
         ...((sh) => (sh !== undefined ? { allowRuleShadow: sh } : {}))(frameShadow),
-        ...((t) => (t !== undefined ? { persistedRuleShadowed: t } : {}))(legacyShadowedRuleTextOf(frameShadow)),
         ...(isWireRecordCarrier(frame.probeCause) ? { probeCause: frame.probeCause } : {}),
         ...((r) => (r !== undefined ? { probeReason: r } : {}))(readProbeReason(frame)),
-        ...(readRememberRefused(frame) ? { rememberRefused: true } : {}),
+        ...(readApprovalRememberRefused(frame) ? { rememberRefused: true } : {}),
         ...(isWireRecordCarrier(frame.ruleEvidence) ? { ruleEvidence: frame.ruleEvidence } : {}),
         ...(frame.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
         ...(hasOwnStrictTrue(frame, 'mandated') ? { mandated: true } : {}),
@@ -1082,9 +1369,18 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             ? { ruleOffersAbsence: frame.ruleOffersAbsence }
             : {}),
         ...(denialLimitFallback !== undefined ? { denialLimitFallback } : {}),
-        ...((o) => (o !== undefined ? { origin: o } : {}))(readOwnNonEmptyString(frame, 'origin')),
+        ...((o) => (o !== undefined ? { origin: o } : {}))(readAskOrigin(frame)),
         ...(readAskClassPair(frame) ?? {}),
+        ...((g) => (g !== undefined ? { boundGrants: g } : {}))(readApprovalBoundGrants(frame)),
+        ...((w) => (w !== undefined ? { classifierNoRuling: w } : {}))(readApprovalClassifierNoRuling(frame)),
     });
+    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`);
+        if (hold.superseded.parked && (card.kind === 'allow' || card.kind === 'deny'))
+            surfaceApprovalParking();
+        return { decision: 'unresolved', retracted: true };
+    }
     if (argsNotRealInput && 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();
@@ -1094,6 +1390,22 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         hostLog('debug', `liveToolApprovalWire: ${approvalId} card retracted without a decision${card.reason ? ` (${card.reason})` : ''} — nothing sent`);
         return { decision: 'unresolved', retracted: true };
     }
+    if (card.kind === 'aborted') {
+        hold.phase = 'respond';
+        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);
+        }
+        hold.trailing = interruptDeny.then(() => undefined, () => undefined);
+        observeCancelByDeny(interruptDeny, approvalId);
+        hostLog('debug', `liveToolApprovalWire: ${approvalId} card aborted — one tool-level deny issued to settle the pending ask`);
+        return { decision: 'unresolved', aborted: true };
+    }
+    hold.phase = 'respond';
     const decision = card.kind === 'allow' ? (card.allowSession ? 'allow_session' : 'allow') : 'deny';
     const denySettledByForWire = card.kind === 'deny' ? readApprovalDenySettledBy(card) : undefined;
     const attributionKeys = decision === 'deny' ? decisionAttributionKeyOf(decidedByReading, denySettledByForWire) : {};