@sema-agent/client-core 0.108.0 → 0.110.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 { 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, 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 { 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, 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 { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, isApprovalRequestFrameV1, } from '@sema-agent/sdk';
+import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, ASK_ORIGINS, } from '@sema-agent/sdk';
 export function toolNameIsFsWrite(name) {
     const n = name.replace(/[\s_-]+/g, '').toLowerCase();
     return (n === 'write' || n === 'filewrite' || n === 'edit' || n === 'fileedit' || n === 'multiedit' || n === 'notebookedit');
@@ -97,6 +100,16 @@ export function readApprovalDenySettledBy(decision) {
         : undefined;
 }
 export const RETRACTED_CARD_DECISION_KIND = 'retracted';
+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(taskId, row, gatedCallId) {
     const d = parkRowDeadlineState(row, Date.now());
     return Object.freeze({
@@ -173,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);
@@ -248,6 +271,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');
@@ -493,6 +524,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     const rowArgsGap = reading.from !== 'none' ? undefined : reading.shape === 'absent' ? 'absent' : reading.shape === 'size_marker' ? 'truncated' : undefined;
     const args = reading.from !== 'none' ? reading.args : rowArgsGap !== undefined ? {} : reading.recorded;
     const argsRewritten = reading.from === 'recorded' && reading.rewritten;
+    const argsFromModelCall = reading.from === 'stream';
     if (typeof args !== 'object' || args === null) {
         return { kind: 'not_sent', ...at, cause: 'no_input', detail: 'gate has no tool input payload' };
     }
@@ -516,6 +548,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')) } : {}),
+        ...inputSourceBitOf(reading),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(pending) ? { requiresRealApproval: true } : {}),
         ...approvalLiveFaceOf(pending).facts,
@@ -538,11 +572,13 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
         allowSessionCarried: true,
         grantBinding: readApprovalGrantBinding(pending),
         parkRow: parkRowOf(taskId, pending, gatedCallId),
+        ...(typeof taskId === 'string' && taskId !== '' ? { taskId } : {}),
     });
+    const editAcceptance = editedApprovalAcceptanceOf(cardRequest);
     const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, cardRequest);
     hold.phase = 'respond';
-    if (rowArgsGap !== undefined && 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' : 'missing from both the stream and the pending row'} — nothing sent (the park stays pending)`);
+    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 };
     }
@@ -555,6 +591,8 @@ 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);
@@ -575,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;
                         }
@@ -597,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) {
@@ -685,8 +746,11 @@ function readReadRootCandidate(v) {
     const o = v;
     if (typeof o.dir !== 'string' || o.dir.length === 0 || o.clearsThisAsk !== true)
         return undefined;
-    if ('covers' in o)
-        return o.covers === 'exact' ? { dir: o.dir, clearsThisAsk: true, covers: 'exact' } : undefined;
+    const covers = inValueOf(o, 'covers');
+    if (covers.state === 'unproven')
+        return undefined;
+    if (covers.state === 'present')
+        return covers.value === 'exact' ? { dir: o.dir, clearsThisAsk: true, covers: 'exact' } : undefined;
     return { dir: o.dir, clearsThisAsk: true };
 }
 export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
@@ -764,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 } : {}),
@@ -771,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) {
@@ -797,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' };
@@ -815,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')
@@ -827,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;
+}
+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;
+    }
+    catch {
+        return false;
+    }
+}
+export function allowNoteNotCarriedSentence(lang) {
+    return renderMessage(msg('approval.allowNote.notCarried'), lang);
 }
 export function observeApprovalAnswerCommitted(listener) {
     answerCommittedListeners.add(listener);
@@ -846,12 +950,30 @@ 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;
+    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')
@@ -969,6 +1091,44 @@ function readReplayedAck(o) {
         ...(o.rememberApplied === false ? { rememberApplied: false } : {}),
     };
 }
+function readParkedRedeemedAck(o) {
+    if (slotReadOf(o, '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 approvalId = text('approvalId');
+    const askId = text('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');
+    let decision;
+    if (replay) {
+        if (dec.presence !== 'present' || (dec.value !== 'allow' && dec.value !== 'deny'))
+            return undefined;
+        decision = dec.value === 'allow' ? 'allow' : 'deny';
+    }
+    else {
+        decision = dec.presence === 'present' && typeof dec.value === 'string' && dec.value !== '' ? dec.value : undefined;
+    }
+    const remember = slotReadOf(o, 'rememberApplied');
+    return {
+        approvalId,
+        askId,
+        accepted: 'parked_redeemed',
+        ...(replay ? { idempotent: true } : {}),
+        ...(decision !== undefined ? { decision } : {}),
+        ...(remember.presence === 'present' && typeof remember.value === 'boolean' ? { rememberApplied: remember.value } : {}),
+    };
+}
+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 !== '');
 }
@@ -1074,19 +1234,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
@@ -1679,7 +1864,7 @@ function v1Bit(stamp) {
 const SUSPENDED_ASK_ARGS_NOTE = "this request's tool arguments are not available on this surface — it was raised while no client was connected, " +
     'so you are deciding without seeing them; deny it if you are not sure what it will do. ' +
     'Edits are not accepted on this card: there is no original input to edit';
-function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
+function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
     const c = carrier;
     const full = leg !== 'generic';
     const live = leg === 'frame' ? carrier : leg === 'v1' ? liveFacts : undefined;
@@ -1707,12 +1892,14 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
             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, wireNote: ARGS_FROM_MODEL_CALL_NOTE, ...inputSourceBitOf(reading) };
             }
             const omitted = c.argsOmitted === true || reading.shape === 'size_marker';
             const fallback = argsFallbackOf(c.message, omitted);
@@ -1743,6 +1930,8 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
         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)
@@ -1778,6 +1967,11 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
                 if (r !== undefined)
                     out.probeReason = r;
             });
+            v1Bit(() => {
+                const by = approvalRequestedByOf(live);
+                if (by !== undefined)
+                    out.requestedBy = by;
+            });
         }
         v1Bit(() => {
             if (readApprovalRememberRefused(carrier))
@@ -1865,8 +2059,11 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
         if (typeof msg === 'string' && msg.trim() !== '')
             out.message = msg;
     });
-    if (leg === 'generic')
+    if (leg === 'generic') {
         out.cardPayloadUnreadable = true;
+        if (payloadWhy !== undefined)
+            out.cardPayloadUnreadableWhy = payloadWhy;
+    }
     if (sessionAllowCarried(leg, approvalId))
         out.allowSessionCarried = true;
     out.grantBinding = readApprovalGrantBinding(carrier);
@@ -1898,17 +2095,29 @@ export function approvalCardFactsOfFrame(frame, opts) {
         return undefined;
     return Object.freeze(cardFactsOf(frame, 'frame', opts));
 }
-export function approvalCardFactsOfGeneric(card) {
+export function approvalCardFactsOfGeneric(card, reading) {
     if (typeof card !== 'object' || card === null)
         return undefined;
-    return Object.freeze(cardFactsOf(card, 'generic'));
+    return Object.freeze(cardFactsOf(card, 'generic', null, undefined, undefined, approvalFrameUnreadableWhyOf(reading)));
 }
 const MAX_RESPOND_NOTE_CHARS = 2048;
 export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane, run) {
+    const approvalId = readOwnDataNonEmptyString(frame, 'approvalId');
+    if (approvalId === undefined)
+        return approvalIdUnreadableRefusal();
+    return surfaceApprovalFrameWithId(frame, approvalId, respond, streamArgs, signal, lane, run);
+}
+function approvalIdUnreadableRefusal() {
+    hostLog('debug', 'liveToolApprovalWire: refused (approvalId_unreadable)');
+    return { kind: 'not_sent', lane: 'respond', cause: 'card_unavailable' };
+}
+export async function surfaceApprovalFrameWithId(frame, approvalId, respond, streamArgs, signal, lane, run) {
     const receivedAtMs = Date.now();
-    const approvalId = frame.approvalId;
+    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 entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, carriers, liveRun), respond, streamArgs, signal, lane, receivedAtMs };
     return enterLiveCard(entry);
 }
 function openingFrameCarriersOf(frame) {
@@ -1916,9 +2125,10 @@ function openingFrameCarriersOf(frame) {
         return { body: frame, live: frame, leg: 'frame' };
     const card = frame.card;
     const pinned = Object.create(frame, { card: { value: card, enumerable: true } });
-    if (isApprovalRequestFrameV1(pinned))
+    const reading = approvalRequestFrameReadingThrowing(pinned);
+    if (reading.v1)
         return { body: pinned.card, live: frame, leg: 'v1' };
-    return { body: typeof card === 'object' && card !== null ? card : {}, live: undefined, leg: 'generic' };
+    return { body: typeof card === 'object' && card !== null ? card : {}, live: undefined, leg: 'generic', why: reading.why };
 }
 function enterLiveCard(e) {
     const { approvalId, signal } = e;
@@ -1933,7 +2143,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);
         noteCallOutcome(slot, out);
         return out;
     });
@@ -1948,15 +2158,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,
@@ -2012,12 +2227,13 @@ 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) {
     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);
+    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) {
         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)'}`);
@@ -2025,6 +2241,7 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
     const card = await surfaceCallTrackedCard(frameToolCallId, approvalId, ledgerSlot, {
         ...facts,
         callKey: liveFrameCallKey(approvalId),
+        ...(cardTaskId !== undefined ? { taskId: cardTaskId } : {}),
         signal: hold.cardSignal,
         ...approvalWindowKeysOf(frame, { windowIsCurrent: lane?.windowIsCurrent === true, receivedAtMs, ...(carriers.leg === 'generic' ? { unknownShape: true } : {}) }),
     });
@@ -2035,11 +2252,13 @@ 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' };
@@ -2073,8 +2292,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;
@@ -2228,15 +2449,15 @@ 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 parsed = settlementAckOf(readToolApprovalRespondAck(raw));
         const replayedForThisCard = parsed !== undefined && isToolApprovalRespondReplayed(parsed) && parsed.approvalId === approvalId;
-        const claimsReplay = ownIdempotentTrue(raw) || (parsed !== undefined && isToolApprovalRespondReplayed(parsed));
+        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 { kind: 'decided', lane: 'respond', decision: claimed.decision };
+                return replayedDecisionOf(claimed.decision, decision, parsed !== undefined && isToolApprovalRespondParkedRedeemed(parsed) && parsed.approvalId === approvalId ? parsed : undefined);
             }
             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');
@@ -2306,6 +2527,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();
@@ -2317,7 +2540,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 } : {}) };