@sema-agent/client-core 0.109.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,22 +17,24 @@ 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 { inValueOf, slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { inValueOf, slotPresenceOf, slotReadOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { APPROVAL_LIVE_FACE_KEYS, approvalLiveFaceOf, hasOwnStrictTrue } from './approvalLiveFace.js';
-import { approvalFrameUnreadableWhyOf, approvalRequestFrameReadingThrowing, } from './approvalRequestFrameReading.js';
+import { approvalFrameUnreadableWhyOf, approvalRequestFrameReadingThrowing, cardPayloadReadingOf, } from './approvalRequestFrameReading.js';
 import { subagentSourceSessionOf } from './subagentSource.js';
 import { isPlainRecord } from '../jsonFaithful.js';
 import { DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED } from '../engineErrorCodes.js';
@@ -98,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({
@@ -174,6 +186,16 @@ export function rememberRefusalOf(error) {
 function rememberRefusalIn(reading) {
     return reading.state === 'code' ? REMEMBER_REFUSAL_CODES.find((c) => c === reading.code) : undefined;
 }
+const FEEDBACK_REFUSAL_CODES = Object.freeze(['feedback_not_in_proof']);
+function feedbackRefusalOf(error) {
+    const reading = readWireErrorCodeReading(error);
+    return reading.state === 'code' && FEEDBACK_REFUSAL_CODES.some((c) => c === reading.code);
+}
+function approveBodyWithoutFeedback(body) {
+    const { feedback: _feedback, ...rest } = body;
+    void _feedback;
+    return rest;
+}
 function logAfterDecided(msg) {
     try {
         hostLog('debug', msg);
@@ -249,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');
@@ -519,6 +549,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')) } : {}),
+        ...inputSourceBitOf(reading),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(pending) ? { requiresRealApproval: true } : {}),
         ...approvalLiveFaceOf(pending).facts,
@@ -541,10 +572,12 @@ 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 || argsFromModelCall) && card.kind === 'allow' && card.updatedInput !== undefined) {
+    if (editAcceptance.state !== 'accepts' && card.kind === 'allow' && card.updatedInput !== undefined) {
         hostLog('error', `liveToolApprovalWire: approval card for ${gatedCallId ?? `task ${taskId}`} returned an edited approval, but the tool input is ${rowArgsGap === 'truncated' ? 'a size marker on the pending row' : rowArgsGap === 'absent' ? 'missing from both the stream and the pending row' : 'not recorded on the pending row'} — nothing sent (the park stays pending)`);
         surfaceEditRefusedOnBlindAsk();
         return { kind: 'not_sent', ...at, cause: 'edit_refused', detail: PARK_EDIT_REFUSED_REASON };
@@ -558,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);
@@ -578,11 +613,30 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const { remember: _remember, ...plainApproveBody } = approveBody;
                     void _remember;
                     emitAnswerCommitted(callKey, 'decide', answered, approveBody);
+                    let feedbackDropped = false;
+                    const sendApprove = async (body) => {
+                        const wire = feedbackDropped ? approveBodyWithoutFeedback(body) : body;
+                        try {
+                            return await bridge.decideTool(wire, gatedCallId, decideOpts, pending);
+                        }
+                        catch (e) {
+                            if (wire.feedback === undefined || !feedbackRefusalOf(e))
+                                throw e;
+                            const verdict = directFailureVerdictOf(e, directSafetyStopOf(e));
+                            if (verdict.yields) {
+                                rememberStop = ownReadingSlot(verdict, 'directStop');
+                                throw e;
+                            }
+                            feedbackDropped = true;
+                            logAfterDecided(`liveToolApprovalWire: decide(approve+feedback) refused the feedback part (${String(e)}) — resending without the note`);
+                            return await bridge.decideTool(approveBodyWithoutFeedback(wire), gatedCallId, decideOpts, pending);
+                        }
+                    };
                     if (approveBody.remember === 'session') {
                         let sessionReceipt;
                         let sessionDecided = false;
                         try {
-                            const raw = await bridge.decideTool(approveBody, gatedCallId, decideOpts, pending);
+                            const raw = await sendApprove(approveBody);
                             sessionReceipt = readDecideReceipt(raw);
                             sessionDecided = true;
                         }
@@ -600,13 +654,17 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                         if (sessionDecided) {
                             if (sessionReceipt?.rememberApplied === false)
                                 surfaceRememberNotApplied();
+                            if (feedbackDropped)
+                                surfaceAllowNoteNotCarried(allowNoteNotCarriedSentence());
                             return { kind: 'decided', ...at, decision: 'allow', ...(sessionReceipt !== undefined ? { receipt: sessionReceipt } : {}) };
                         }
                     }
-                    const raw = await bridge.decideTool(plainApproveBody, gatedCallId, decideOpts, pending);
+                    const raw = await sendApprove(plainApproveBody);
                     const receipt = readDecideReceipt(raw);
                     if (rememberRefused || sessionDowngraded)
                         surfaceRememberNotApplied();
+                    if (feedbackDropped)
+                        surfaceAllowNoteNotCarried(allowNoteNotCarriedSentence());
                     return { kind: 'decided', ...at, decision: 'allow', ...(receipt !== undefined ? { receipt } : {}) };
                 }
                 catch (e) {
@@ -770,6 +828,12 @@ export function toolPermissionRequestAskBits(card, requestId) {
     const origin = readAskOrigin(card);
     const ruleOffersAbsence = readOwnNonEmptyString(card, 'ruleOffersAbsence');
     const askClassPair = readAskClassPair(card);
+    const probeLayer = probeCarrierOf(card);
+    const probe = probeFactsAt(probeLayer);
+    const onTop = probeLayer === card;
+    const requestedBy = onTop ? approvalRequestedByOf(card) : undefined;
+    const payload = onTop ? cardPayloadReadingOf(card) : undefined;
+    const inputSource = onTop ? approvalInputSourceOf(card) : undefined;
     return {
         ...(mandated ? { mandated: true } : {}),
         ...(mandate !== undefined ? { mandate } : {}),
@@ -777,6 +841,12 @@ export function toolPermissionRequestAskBits(card, requestId) {
         ...(ruleOffersAbsence !== undefined ? { ruleOffersAbsence } : {}),
         ...(askClassPair ?? {}),
         ...(seatSessionRowOf(card, requestId) ? { sessionRow: true } : {}),
+        ...(probe.prose !== undefined ? { probeReason: probe.prose } : {}),
+        ...(probe.cause !== undefined ? { probeCause: probe.cause } : {}),
+        ...(seatAllowNoteCarriedOf(card, requestId) ? { feedbackCapable: true } : {}),
+        ...(requestedBy !== undefined ? { requestedBy } : {}),
+        ...(payload !== undefined && payload.payloadUnreadable && payload.why !== undefined ? { frameReading: payload.why } : {}),
+        ...(inputSource !== undefined ? { inputSource } : {}),
     };
 }
 function isToolApprovalDelegation(v) {
@@ -803,6 +873,14 @@ function respondDecisionOfAnswer(answer) {
         return answer.allowSession ? 'allow_session' : 'allow';
     return answer.kind === 'deny' ? 'deny' : undefined;
 }
+export function allowNoteReadingOf(answer) {
+    const note = readOwnDataValue(answer, 'note');
+    if (note === undefined)
+        return { kind: 'absent' };
+    if (typeof note !== 'string')
+        return { kind: 'invalid' };
+    return note.trim() === '' ? { kind: 'blank' } : { kind: 'text', text: note };
+}
 function respondNoteGate(reason, capable) {
     if (reason === undefined || reason.trim() === '')
         return { dropped: 'blank' };
@@ -821,10 +899,14 @@ export function answerPayloadFor(answer, lane, caps) {
             const reason = answer.kind === 'deny' && typeof answer.reason === 'string' ? answer.reason : undefined;
             return Object.freeze({ decision: 'deny', reason: denyReasonForWire(reason, 'answer') ?? DEFAULT_DENY_REASON });
         }
+        const fb = allowNoteReadingOf(answer);
+        if (fb.kind === 'invalid')
+            hostLog('error', `answerPayloadFor: the allow note must be a string (got ${typeof readOwnDataValue(answer, 'note')}) — not sent as feedback; the decision itself is sent`);
         return Object.freeze({
             decision: 'approve',
             ...(word === 'allow_session' ? { remember: 'session' } : {}),
             ...(answer.updatedInput !== undefined ? { updatedInput: answer.updatedInput } : {}),
+            ...(fb.kind === 'text' ? { feedback: fb.text } : {}),
         });
     }
     if (answer.kind === 'allow')
@@ -833,9 +915,25 @@ export function answerPayloadFor(answer, lane, caps) {
     return Object.freeze({ decision: word, ...('note' in gate ? { note: gate.note } : {}) });
 }
 const ANSWER_CARRIAGE_NONE = Object.freeze({ allowNote: 'none' });
+const ANSWER_CARRIAGE_MODEL = Object.freeze({ allowNote: 'model' });
 export function answerCarriage(card) {
-    void card;
-    return ANSWER_CARRIAGE_NONE;
+    return cardIsOnParkRow(card) ? ANSWER_CARRIAGE_MODEL : ANSWER_CARRIAGE_NONE;
+}
+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);
@@ -852,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')
@@ -975,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 !== '');
 }
@@ -1080,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
@@ -1713,12 +1892,14 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
             if (reading.from === 'recorded') {
                 if (blind)
                     return { args: reading.args, argsUnavailable: true };
-                return reading.rewritten ? { args: reading.args, argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE } : { args: reading.args };
+                return reading.rewritten
+                    ? { args: reading.args, argsRewritten: true, wireNote: ARGS_REWRITTEN_NOTE, ...inputSourceBitOf(reading) }
+                    : { args: reading.args, ...inputSourceBitOf(reading) };
             }
             if (reading.from === 'stream' && typeof reading.args === 'object' && reading.args !== null) {
                 if (blind)
                     return { args: reading.args, argsUnavailable: true };
-                return { args: reading.args, wireNote: ARGS_FROM_MODEL_CALL_NOTE };
+                return { args: reading.args, wireNote: ARGS_FROM_MODEL_CALL_NOTE, ...inputSourceBitOf(reading) };
             }
             const omitted = c.argsOmitted === true || reading.shape === 'size_marker';
             const fallback = argsFallbackOf(c.message, omitted);
@@ -1749,6 +1930,8 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
         out.argsUnavailable = true;
     if (argsPart.argsRewritten === true)
         out.argsRewritten = true;
+    if (argsPart.inputSource !== undefined)
+        out.inputSource = argsPart.inputSource;
     if (full) {
         v1Bit(() => {
             if (c.governanceForced === true)
@@ -1784,6 +1967,11 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId, payloadWhy) {
                 if (r !== undefined)
                     out.probeReason = r;
             });
+            v1Bit(() => {
+                const by = approvalRequestedByOf(live);
+                if (by !== undefined)
+                    out.requestedBy = by;
+            });
         }
         v1Bit(() => {
             if (readApprovalRememberRefused(carrier))
@@ -1928,7 +2116,8 @@ export async function surfaceApprovalFrameWithId(frame, approvalId, respond, str
     if (typeof approvalId !== 'string' || approvalId === '')
         return approvalIdUnreadableRefusal();
     const carriers = openingFrameCarriersOf(frame);
-    const entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, frame, carriers, run), respond, streamArgs, signal, lane, receivedAtMs };
+    const liveRun = liveCardRunOf(frame, run);
+    const entry = { frame, carriers, approvalId, identity: liveCardIdentityOf(approvalId, carriers, liveRun), respond, streamArgs, signal, lane, receivedAtMs };
     return enterLiveCard(entry);
 }
 function openingFrameCarriersOf(frame) {
@@ -1954,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;
     });
@@ -1969,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,
@@ -2033,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, 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)'}`);
@@ -2046,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 } : {}) }),
     });
@@ -2056,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' };
@@ -2094,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;
@@ -2249,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');
@@ -2327,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();
@@ -2338,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 } : {}) };

package/dist/hooksWireCaps.js

@@ -9,7 +9,7 @@ import { admittedLayers, layerAdmissionWord } from './settingsLayerAdmission.js'
 import { guardedRead, readOwnDataValue } from './ownKey.js';
 import { HOOK_SETTINGS_SOURCE_TEXT, hooksSalvageMaskOf, salvageSettingsHooksEntries, settingsHooksSalvageNotice } from './settingsHooksSalvage.js';
 import { submissionOriginOf } from './request/submissionIdentity.js';
-import { createSettingsHookJudge, decidePluginHooks, decideSessionHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, hooksWirePlanShapeOf, occupancyOf, } from './pluginHooksWire.js';
+import { createSettingsHookJudge, decidePluginHooks, decideSessionHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, hooksWirePlanShapeOf, isEngineFiredHookEvent, occupancyOf, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { applyHttpHookPolicy, httpHookAdmittedSources, readHttpHookPolicy, wireHasHttpEntry } from './httpHookPolicy.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
@@ -300,6 +300,32 @@ function withheldRowsOf(candidates, trust, layers) {
     }
     return rows;
 }
+function closedDropRowsOf(source, doc, reason) {
+    const rows = [];
+    try {
+        const hooks = readOwnDataValue(doc, 'hooks');
+        if (typeof hooks !== 'object' || hooks === null || Array.isArray(hooks))
+            return rows;
+        for (const event of Object.keys(hooks)) {
+            const groups = readOwnDataValue(hooks, event);
+            if (!Array.isArray(groups))
+                continue;
+            groups.forEach((group, groupIndex) => {
+                if (typeof group !== 'object' || group === null)
+                    return;
+                const entries = readOwnDataValue(group, 'hooks');
+                if (!Array.isArray(entries))
+                    return;
+                entries.forEach((_entry, hookIndex) => {
+                    rows.push({ source, event, groupIndex, hookIndex, reason, notRun: true });
+                });
+            });
+        }
+    }
+    catch {
+    }
+    return rows;
+}
 function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppressedLocally, readerNotRead, compactionOnShell = false) {
     const settingsDropped = [];
     const settingsVerdicts = [];
@@ -333,6 +359,8 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
     });
     const closedPlan = (reason) => {
         closedBy = reason;
+        for (const source of ALL_HOOK_SOURCES)
+            settingsDropped.push(...closedDropRowsOf(source, read.layers[source].doc, reason));
         sessionReader = read.sessionHooks.state;
         const pr = read.plugins;
         if (pr.reading === undefined)
@@ -472,6 +500,8 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
             settingsDropped.push(...kept.drops);
             settingsVerdicts.push(...kept.verdicts);
             settingsExcluded.push(...kept.excluded);
+            if (!isEngineFiredHookEvent(event))
+                continue;
             settingsStripped += kept.stripped;
             if (kept.groups.length === 0)
                 continue;