@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/hitl/decisionRefusal.js

@@ -1,25 +1,32 @@
-import { ASK_GONE, ASK_GONE_PARKED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { ASK_GONE, ASK_GONE_PARKED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, isDecideRowUnrevivableCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { isUiLanguage } from '../env/uiLanguage.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { notPendingCauseReading, refusalCauseWordOf } from './approvalEndingCause.js';
-import { GATE_FAILURE_CODES, readDecideCurrentPending, readWireCodes } from './hitlBridge.js';
+import { GATE_FAILURE_CODES, readDecideCurrentPending, readWireCodes, refusalCarrierOf } from './hitlBridge.js';
 import { isAlreadyResolvedGateReason, isCodeClassifiedGateFailure } from './parkResolver.js';
 import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
-import { PROTOCOL_ERROR_NAME, isDisplayableWireCode, protocolErrorNameReading, readErrorRecord, readRefusalField } from '../wireFailureShape.js';
-import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorRecord, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
+import { attributionRefusalOf, carrierReadOf } from './attributionLadder.js';
+import { CODE_UNREADABLE, ownReadingSlot } from '../engineWireFor.js';
 export const ASK_DECIDED_CODE = 'conflict.ask_decided';
 const TRANSIENT_STATUSES = new Set([408, 425, 429, 502, 503, 504]);
-export function refusalCarrierOf(err) {
-    if (typeof err !== 'object' || err === null)
-        return { carrier: err };
-    const name = guardedRead(() => readOwnDataValue(err, 'name'));
-    if (name !== 'HitlSafetyError')
-        return { carrier: err };
-    const code = guardedRead(() => readOwnDataValue(err, 'code'));
-    const local = typeof code === 'string' && GATE_FAILURE_CODES.includes(code) ? code : undefined;
-    const cause = guardedRead(() => readOwnDataValue(err, 'cause'));
-    const carrier = typeof cause === 'object' && cause !== null ? cause : err;
-    return local !== undefined ? { local, carrier } : { carrier };
+export { refusalCarrierOf } from './hitlBridge.js';
+const DELIVERED_UNREADABLE = Symbol('delivered-answer-unreadable');
+function deliveredAnswerOf(delivered, carrier) {
+    if (delivered === undefined)
+        return undefined;
+    const a = ownReadingSlot(delivered, 'answered') ?? ownReadingSlot(delivered, 'unanswered');
+    return a !== undefined && a.layer === carrier ? a : DELIVERED_UNREADABLE;
+}
+const PROTOCOL_NAME_ABSENT = Object.freeze({ state: 'absent' });
+const PROTOCOL_NAME_UNREADABLE = Object.freeze({ state: 'unreadable' });
+function capturedCodeOf(answer) {
+    return answer === undefined ? undefined : answer === DELIVERED_UNREADABLE ? CODE_UNREADABLE : answer.code;
+}
+export function notPendingAfterRetry(status, retried) {
+    return retried && (status === 404 || status === 410);
 }
 const ROUTE_WORDS = { approval_decide: true, live_respond: true, ask_decide: true, plan_review: true, compact: true };
 const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
@@ -35,17 +42,19 @@ function routeOf(context) {
     return typeof r === 'string' && REFUSAL_ROUTES.includes(r) ? r : undefined;
 }
 function carrierStatus(carrier) {
-    const raw = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataValue(carrier, 'status')) : undefined;
+    const raw = isSlotCarrier(carrier) ? readThrownSlot(carrier, 'status', 'data') : undefined;
     return typeof raw === 'number' && Number.isFinite(raw) ? raw : undefined;
 }
-function carrierCode(carrier) {
-    const raw = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataValue(carrier, 'errorCode')) : undefined;
+function carrierCode(carrier, captured) {
+    if (captured !== undefined)
+        return captured.state === 'read' ? captured.wire : undefined;
+    const raw = isSlotCarrier(carrier) ? readThrownSlot(carrier, 'errorCode', 'data') : undefined;
     return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
 }
-export function refusalDeliveryOf(err, context) {
-    const { carrier } = refusalCarrierOf(err);
-    const status = carrierStatus(carrier);
-    const errorCode = carrierCode(carrier);
+export function refusalDeliveryOf(err, context, answer, read) {
+    const { carrier } = read ?? refusalCarrierOf(err);
+    const status = answer === undefined ? carrierStatus(carrier) : answer === DELIVERED_UNREADABLE ? undefined : answer.status;
+    const errorCode = carrierCode(carrier, capturedCodeOf(answer));
     const facts = { ...(status !== undefined ? { status } : {}), ...(errorCode !== undefined ? { errorCode } : {}) };
     if (status === undefined || !Number.isInteger(status) || status < 400 || status > 599)
         return { delivery: 'no_answer', ...facts };
@@ -61,6 +70,9 @@ export function decisionRefusalSaysAskGone(err) {
     return readDecisionRefusalAsk(err).reading === 'settled';
 }
 const facts = (reading, gateMoved = false, wordingHint = false) => ({ reading, gateMoved, wordingHint });
+const codeUnreadable = () => {
+    throw new TypeError('status or errorCode was unreadable when this failure was first read');
+};
 function preflightSettledBitsPresent(carrier) {
     const detail = guardedRead(() => readErrorRecord(carrier, 'detail'));
     if (detail === undefined)
@@ -96,28 +108,31 @@ function askFactsOfResolution(r) {
         return facts('unreadable');
     }
 }
-export function readDecisionRefusalAsk(failure) {
-    if (typeof failure !== 'object' || failure === null)
+export function readDecisionRefusalAsk(failure, answer, read) {
+    if (!isSlotCarrier(failure))
         return facts('not_settled');
-    if (isResolutionShaped(failure))
+    if (answer === undefined && isResolutionShaped(failure))
         return askFactsOfResolution(failure);
-    const { local, carrier } = refusalCarrierOf(failure);
+    const r = read ?? refusalCarrierOf(failure);
+    const local = ownReadingSlot(r, 'local');
+    const carrier = r.carrier;
     if (local !== undefined)
         return facts(local === 'no_pending' ? 'settled' : 'not_settled');
-    if (typeof carrier !== 'object' || carrier === null)
+    if (!isSlotCarrier(carrier))
         return facts('not_settled');
     let localCode, name, protocolName, errorCode, status, retriable, text;
     try {
         const slot = (key) => ownDataField(carrier, key);
         const closed = (v) => (typeof v === 'string' && GATE_FAILURE_CODES.includes(v) ? v : undefined);
-        localCode = closed(slot('code'));
+        localCode = closed(answer === undefined ? slot('code') : answer === DELIVERED_UNREADABLE || answer.localCode === THROWN_SLOT_UNREADABLE ? codeUnreadable() : answer.localCode);
         name = slot('name');
-        const pn = protocolErrorNameReading(carrier);
+        const pn = read !== undefined ? read.protocolName : protocolErrorNameReading(carrier);
         if (pn.state === 'unreadable')
             throw new TypeError('protocol name unreadable');
         protocolName = pn.state === 'named' ? pn.name : undefined;
-        errorCode = slot('errorCode');
-        status = slot('status');
+        const captured = capturedCodeOf(answer);
+        errorCode = captured === undefined ? slot('errorCode') : captured.state === 'read' ? captured.wire : codeUnreadable();
+        status = answer === undefined ? slot('status') : answer === DELIVERED_UNREADABLE ? codeUnreadable() : answer.status;
         retriable = refusalRetriableReading(carrier);
         text = String(carrier);
     }
@@ -152,7 +167,7 @@ export function decisionRefusalAskReading(failure) {
 }
 const USELESS_REFUSAL_TEXTS = new Set(['[object Object]', 'null', 'undefined', '']);
 function refusalTextOf(err) {
-    const message = typeof err === 'object' && err !== null ? guardedRead(() => err.message) : undefined;
+    const message = isSlotCarrier(err) ? guardedRead(() => err.message) : undefined;
     if (typeof message === 'string' && message.length > 0)
         return message;
     if (typeof err === 'string' && err.length > 0)
@@ -169,27 +184,49 @@ function refusalTextOf(err) {
 function isolated(read) {
     return guardedRead(read);
 }
-export function mintDecisionRefusalReading(err, context, attributionCarried) {
-    const { carrier } = refusalCarrierOf(err);
-    const obj = typeof carrier === 'object' && carrier !== null ? carrier : undefined;
-    const status = carrierStatus(carrier);
-    const wire = obj !== undefined ? isolated(() => readWireCodes(obj)) : undefined;
-    const errorCode = wire?.errorCode ?? carrierCode(carrier);
+function wireCodesOfPinned(captured) {
+    if (captured.state !== 'read' || captured.wire === undefined)
+        return {};
+    return { errorCode: captured.wire, ...(captured.blockedBy !== undefined ? { blockedBy: captured.blockedBy } : {}) };
+}
+export function mintDecisionRefusalReading(err, context, attributionCarried, delivered, carried) {
+    const carrierRead = carried ?? carrierReadOf(err, delivered);
+    const { carrier } = carrierRead;
+    const obj = isSlotCarrier(carrier) ? carrier : undefined;
+    const answer = deliveredAnswerOf(delivered, carrier);
+    const captured = capturedCodeOf(answer);
+    const status = answer === undefined ? carrierStatus(carrier) : answer === DELIVERED_UNREADABLE ? undefined : answer.status;
+    const wire = captured !== undefined ? wireCodesOfPinned(captured) : obj !== undefined ? isolated(() => readWireCodes(obj)) : undefined;
+    const wireBits = ownFoldedCodeBitsOf(wire);
+    const errorCode = wireBits.errorCode ?? carrierCode(carrier, captured);
+    const blockedBy = wireBits.blockedBy;
     const message = isolated(() => refusalTextOf(carrier));
     const retriable = obj !== undefined && isolated(() => refusalSaysStillPending(obj)) === true;
-    const pn = obj !== undefined ? isolated(() => protocolErrorNameReading(obj)) : undefined;
-    const protocolName = pn?.state === 'named' ? pn.name : undefined;
+    const pn = obj !== undefined ? (isolated(() => protocolErrorNameReading(obj)) ?? PROTOCOL_NAME_UNREADABLE) : PROTOCOL_NAME_ABSENT;
+    const protocolName = pn.state === 'named' ? pn.name : undefined;
     const cause = obj !== undefined ? isolated(() => refusalCauseWordOf(obj)) : undefined;
     const field = obj !== undefined ? isolated(() => readRefusalField(obj)) : undefined;
     const currentPending = obj !== undefined ? isolated(() => readDecideCurrentPending(obj)) : undefined;
-    const attribution = attributionCarried !== undefined ? isolated(() => denyAttributionRefusalFromError(carrier, attributionCarried)) : undefined;
-    const ask = readDecisionRefusalAsk(err);
-    const delivery = refusalDeliveryOf(err, context);
-    const standing = delivery.delivery === 'no_answer' ? undefined : ask.reading === 'settled' ? 'settled-elsewhere' : delivery.delivery === 'refused' ? 'refused-pending' : 'ambiguous';
+    const attribution = attributionCarried === undefined ? undefined : isolated(() => attributionRefusalOf(carrierRead, delivered ?? 'carrier', attributionCarried));
+    const ask = readDecisionRefusalAsk(err, answer, { ...carrierRead, protocolName: pn });
+    const delivery = refusalDeliveryOf(err, context, answer, carrierRead);
+    const unknownAfterRetry = guardedRead(() => (typeof context === 'object' && context !== null ? readOwnDataValue(context, 'afterRetry') : undefined)) === true && notPendingAfterRetry(status, true);
+    const standing = delivery.delivery === 'no_answer'
+        ? undefined
+        : unknownAfterRetry
+            ? 'ambiguous'
+            : ask.reading === 'settled'
+                ? 'settled-elsewhere'
+                : delivery.delivery === 'refused'
+                    ? 'refused-pending'
+                    : 'ambiguous';
     const inRange = standing !== undefined && status !== undefined;
+    const conflict = inRange && status === 409 && obj !== undefined ? isolated(() => decisionConflictOf(obj, captured, pn)) : undefined;
+    const unrecoverable = inRange && status !== undefined && Number.isInteger(status) && status >= 400 && status <= 599 && isDecideRowUnrevivableCode(errorCode);
     const transient = inRange &&
+        conflict !== 'grant_changed' &&
+        !unrecoverable &&
         (TRANSIENT_STATUSES.has(status) || retriable || (status === 404 && obj !== undefined && isolated(() => notPendingCauseReading(obj)) === 'other_replica'));
-    const conflict = inRange && status === 409 && obj !== undefined ? isolated(() => decisionConflictOf(obj)) : undefined;
     return Object.freeze({
         ...(status !== undefined ? { status } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
@@ -197,7 +234,7 @@ export function mintDecisionRefusalReading(err, context, attributionCarried) {
         ...(retriable ? { retriable: true } : {}),
         ...(protocolName !== undefined ? { protocolName } : {}),
         ...(cause !== undefined || field !== undefined ? { extra: Object.freeze({ ...(cause !== undefined ? { cause } : {}), ...(field !== undefined ? { field } : {}) }) } : {}),
-        ...(wire?.blockedBy !== undefined ? { blockedBy: wire.blockedBy } : {}),
+        ...(blockedBy !== undefined ? { blockedBy } : {}),
         ...(currentPending !== undefined ? { currentPending } : {}),
         ...(attribution !== undefined && attribution !== null ? { denyAttributionRefusal: attribution } : {}),
         ask: ask.reading,
@@ -206,6 +243,7 @@ export function mintDecisionRefusalReading(err, context, attributionCarried) {
         ...(standing !== undefined ? { standing } : {}),
         ...(transient ? { transient: true } : {}),
         ...(conflict !== undefined ? { conflict } : {}),
+        ...(unrecoverable ? { unrecoverable: true } : {}),
     });
 }
 export function readDecisionRefusalReading(err, context) {
@@ -223,12 +261,14 @@ function classifiedOf(reading) {
         const errorCode = typeof code === 'string' && isDisplayableWireCode(code) ? code : undefined;
         const transient = ownDataField(reading, 'transient') === true;
         const conflict = ownDataField(reading, 'conflict');
+        const unrecoverable = ownDataField(reading, 'unrecoverable') === true;
         return Object.freeze({
             standing,
             status,
             ...(errorCode !== undefined ? { errorCode } : {}),
             ...(transient ? { transient: true } : {}),
             ...(typeof conflict === 'string' ? { conflict: conflict } : {}),
+            ...(unrecoverable ? { unrecoverable: true } : {}),
         });
     }
     catch {
@@ -242,6 +282,9 @@ export function classifyDecisionRefusal(err, context) {
     }
     return classifiedOf(mintDecisionRefusalReading(err, context));
 }
+export function classifyDeliveredDecisionRefusal(err, delivered) {
+    return classifiedOf(mintDecisionRefusalReading(err, undefined, undefined, delivered));
+}
 export function liveAskPendingReading(envelope, approvalId) {
     if (typeof approvalId !== 'string' || approvalId === '')
         return 'unknown';
@@ -260,15 +303,14 @@ export function liveAskPendingReading(envelope, approvalId) {
 export function decisionRefusalClosesOut(refusal, pending) {
     if (pending !== 'pending' || typeof refusal !== 'object' || refusal === null)
         return false;
-    try {
-        const standing = refusal.standing;
-        if (refusal.transient === true)
-            return false;
-        return standing === 'ambiguous' || standing === 'refused-pending';
-    }
-    catch {
+    const standing = readThrownSlot(refusal, 'standing', 'data');
+    const transient = readThrownSlot(refusal, 'transient', 'data');
+    if (transient === true || transient === THROWN_SLOT_UNREADABLE)
         return false;
-    }
+    const conflict = readThrownSlot(refusal, 'conflict', 'data');
+    if (conflict === 'grant_changed' || conflict === THROWN_SLOT_UNREADABLE)
+        return false;
+    return standing === 'ambiguous' || standing === 'refused-pending';
 }
 export function undeliverableDecisionContent(facts) {
     const code = typeof facts.errorCode === 'string' && isDisplayableWireCode(facts.errorCode) ? ` ${facts.errorCode}` : '';
@@ -284,3 +326,6 @@ export function undeliverableDecisionContent(facts) {
             return `${head}; this turn was stopped instead of being left waiting. Update the client, or switch to a permission mode that shows you the approval and try again.`;
     }
 }
+export function decideRowUnrevivableNotice(lang) {
+    return renderMessage(msg('notice.decide.rowUnrevivable'), isUiLanguage(lang) ? lang : undefined);
+}

package/dist/hitl/decisionSend.d.ts

@@ -1,4 +1,5 @@
 import type { AgentClient, ElicitResponse } from '@sema-agent/sdk';
+import type { UiLanguage } from '../env/uiLanguage.js';
 import { type AskGoneDetail } from '../decideReceipt.js';
 import type { ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecisionNoteAudit } from './approvalDecisionNoteAudit.js';
@@ -65,6 +66,7 @@ interface HitlDecisionOutcomeBase {
     readonly attributionDropped?: true;
     readonly attributionRenamed?: true;
     readonly pending?: LiveAskPendingReading;
+    readonly parkingRetried?: true;
 }
 export interface HitlDecisionApplied extends HitlDecisionOutcomeBase {
     readonly kind: 'applied';
@@ -110,4 +112,5 @@ export interface HitlDecisionSendTiming {
 export declare function __setHitlDecisionSendTimingForTests(t?: HitlDecisionSendTiming): void;
 export declare function hitlAskIdempotencyKey(askId: string, verdict: 'approve' | 'deny'): string;
 export declare function sendHitlDecision(request: HitlDecisionSendRequest, deps: HitlDecisionSendDeps): Promise<HitlDecisionSendOutcome>;
+export declare function hitlDecisionOutcomeContent(outcome: HitlDecisionSendOutcome, lang?: UiLanguage): string | undefined;
 export {};

package/dist/hitl/decisionSend.js

@@ -1,13 +1,15 @@
-import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
+import { settleWithinDeadline } from '../abortableSleep.js';
 import { hostLog } from '../host.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { askGoneFromError } from '../decideReceipt.js';
-import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
-import { effectiveWireErrorCode, isWireTransportError } from '../wireErrorTriage.js';
+import { appendOwnElement, guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
+import { effectiveCodeOf, ownReadingSlot } from '../engineWireFor.js';
 import { ASK_DECISION_LANE_DISABLED, ASK_GONE, ASK_GONE_PARKED, ASK_IDEMPOTENCY_CONFLICT, ASK_NOT_FOUND, ASK_PARKING_RETRY } from '../engineErrorCodes.js';
-import { readErrorNumber, readErrorString, readThrownSlot, readThrownStatusSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
+import { isSlotCarrier, readErrorNumber, readErrorString, readThrownSlot } from '../wireFailureShape.js';
 import { readDecisionNoteAudit } from './approvalDecisionNoteAudit.js';
-import { deliverWithAttributionLadder } from './attributionLadder.js';
-import { ASK_DECIDED_CODE, classifyDecisionRefusal, decisionRefusalClosesOut } from './decisionRefusal.js';
+import { carrierReadOf, deliverWithAttributionLadder, isLocalSafetyStop } from './attributionLadder.js';
+import { budgetSpent, deliverApprovalDecision, deliveryTiming, isAborted, newSendTally, PARKING_WAIT_CAP_MS, setDeliveryTimingForTests, sleepFor, settledTransportReadingOf, withTransportRetry, deliveryReadingOf, } from './approvalDelivery.js';
+import { ASK_DECIDED_CODE, classifyDeliveredDecisionRefusal, decisionRefusalClosesOut, notPendingAfterRetry } from './decisionRefusal.js';
 import { addDecisionOpKeys, closeDecisionOp, decisionLedgerKeysOf, decisionOpsWithKey, openDecisionOp } from './decisionLedger.js';
 import { hostHoldIsActive, takeHostHoldLedgerOp, tryHoldApprovalNow } from './approvalHolds.js';
 import { answerPayloadFor, decisionAttributionKeyOf, isToolApprovalRespondReplayed, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, } from './toolApprovalWire.js';
@@ -15,86 +17,19 @@ export const HITL_DECISION_FAMILIES = Object.freeze(['approval', 'ask', 'elicita
 export const HITL_DECISION_NOT_APPLIED_CAUSES = Object.freeze(['gone', 'parked', 'parking', 'lane_disabled', 'refused', 'idempotency_crossed']);
 export const HITL_DECISION_UNCONFIRMED_CAUSES = Object.freeze(['transport', 'server_error', 'local_error', 'aborted', 'gone_after_retry']);
 export const HITL_DECISION_NOT_SENT_CAUSES = Object.freeze(['aborted', 'duplicate_in_flight', 'invalid_request', 'no_verb', 'not_an_answer']);
-const RETRY_DELAYS_MS = Object.freeze([500, 1_000, 2_000]);
-const RETRY_BUDGET_MS = 8_000;
 const PARKING_POLL_MAX = 2;
 const PARKING_POLL_DELAY_MS = 400;
-const PARKING_POLL_WAIT_CAP_MS = 5_000;
 export const HITL_DECISION_READBACK_BUDGET_MS = 4_000;
 const IDEMPOTENCY_KEY_MAX = 255;
-let timingOverride;
 export function __setHitlDecisionSendTimingForTests(t) {
-    timingOverride = t;
+    setDeliveryTimingForTests(t);
 }
 export function hitlAskIdempotencyKey(askId, verdict) {
     const key = `sema-ask:${askId}:${verdict}`;
     return key.length <= IDEMPOTENCY_KEY_MAX ? key : key.slice(0, IDEMPOTENCY_KEY_MAX);
 }
-function isAbortShaped(e) {
-    const name = readThrownSlot(e, 'name');
-    return name === 'TimeoutError' || name === 'AbortError';
-}
-function transportClassOf(e, signal) {
-    if (signal?.aborted === true)
-        return 'aborted';
-    const status = typeof e === 'object' && e !== null ? readThrownStatusSlot(e) : undefined;
-    if (status === THROWN_SLOT_UNREADABLE)
-        return 'local_error';
-    if (typeof status === 'number')
-        return status === 501 ? 'verdict' : status >= 500 ? 'server_5xx' : 'verdict';
-    return isWireTransportError(e) || isAbortShaped(e) ? 'transport' : 'local_error';
-}
-function attemptSignal(attempt, caller, startedAt, budgetMs) {
-    if (attempt === 1)
-        return caller;
-    const deadline = AbortSignal.timeout(Math.max(1, budgetMs - (Date.now() - startedAt)));
-    if (caller === undefined)
-        return deadline;
-    if (typeof AbortSignal.any === 'function')
-        return AbortSignal.any([caller, deadline]);
-    const ac = new AbortController();
-    const abort = (s) => ac.abort(s.reason);
-    if (caller.aborted)
-        abort(caller);
-    else
-        caller.addEventListener('abort', () => abort(caller), { once: true });
-    deadline.addEventListener('abort', () => abort(deadline), { once: true });
-    return ac.signal;
-}
-function budgetSpent(tally, extraMs) {
-    return Date.now() - tally.startedAt + extraMs >= (timingOverride?.budgetMs ?? RETRY_BUDGET_MS);
-}
-function isAborted(signal) {
-    return signal?.aborted === true;
-}
-function sleepFor(ms, signal) {
-    return abortableSleep(ms, signal ?? new AbortController().signal);
-}
-async function withTransportRetry(send, signal, tally) {
-    const delays = timingOverride?.delays ?? RETRY_DELAYS_MS;
-    const budgetMs = timingOverride?.budgetMs ?? RETRY_BUDGET_MS;
-    const startedAt = tally.startedAt;
-    for (let attempt = 1;; attempt++) {
-        tally.attempts++;
-        try {
-            return await send(attemptSignal(attempt, signal, startedAt, budgetMs));
-        }
-        catch (e) {
-            const cls = transportClassOf(e, signal);
-            const delay = delays[attempt - 1] ?? 0;
-            const retriable = cls === 'transport' || cls === 'server_5xx';
-            const overBudget = Date.now() - startedAt + delay >= budgetMs;
-            if (!retriable || attempt > delays.length || overBudget)
-                throw e;
-            tally.retried = true;
-            await sleepFor(delay, signal);
-            if (signal?.aborted === true)
-                throw e;
-        }
-    }
-}
 function retryAfterMsOf(e) {
-    if (typeof e !== 'object' || e === null)
+    if (!isSlotCarrier(e))
         return undefined;
     const ms = readErrorNumber(e, 'retryAfterMs');
     if (ms !== undefined && Number.isFinite(ms) && ms >= 0)
@@ -115,21 +50,32 @@ function actorLabelOf(e) {
 function verdictOf(word) {
     return word === 'approve' || word === 'allow' || word === 'allow_session' ? 'approve' : word === 'deny' ? 'deny' : undefined;
 }
-function outcomeOfThrown(e, family, ours, signal, tally, noteCapable) {
+function outcomeOfThrown(e, family, ours, signal, tally, noteCapable, reading = settledTransportReadingOf(e, signal, tally)) {
     const base = { family, attempts: tally.attempts };
-    const cls = transportClassOf(e, signal);
+    const cls = reading.cls;
     if (cls === 'aborted')
         return { ...base, kind: 'unconfirmed', cause: 'aborted' };
     if (cls === 'transport')
         return { ...base, kind: 'unconfirmed', cause: 'transport' };
     if (cls === 'local_error')
         return { ...base, kind: 'unconfirmed', cause: 'local_error' };
+    const answered = ownReadingSlot(reading, 'answered');
+    if (answered === undefined)
+        return { ...base, kind: 'unconfirmed', cause: 'local_error' };
+    return answeredOutcome(answered.layer, answered.status, reading, cls, family, ours, tally, noteCapable, base);
+}
+function answeredOutcome(e, status, reading, cls, family, ours, tally, noteCapable, base) {
     const obj = e;
-    const status = readThrownStatusSlot(obj);
     if (cls === 'server_5xx')
         return { ...base, kind: 'unconfirmed', cause: 'server_error', status };
-    const code = effectiveWireErrorCode(e);
+    const answeredCapture = ownReadingSlot(reading, 'answered');
+    const code = answeredCapture !== undefined ? effectiveCodeOf(answeredCapture.code) : undefined;
     const at = { ...base, status, ...(code !== undefined ? { errorCode: code } : {}) };
+    const retried = family !== 'ask' && tally.retried;
+    if (retried && notPendingAfterRetry(status, true))
+        return { ...base, kind: 'unconfirmed', cause: 'gone_after_retry', status };
+    if (isSafetyStopLayer(e, reading))
+        return { ...at, kind: 'not_applied', cause: 'refused', ...refusalOf(e, reading) };
     if (family === 'ask') {
         switch (code) {
             case ASK_DECIDED_CODE: {
@@ -148,7 +94,7 @@ function outcomeOfThrown(e, family, ours, signal, tally, noteCapable) {
                 };
             }
             case ASK_IDEMPOTENCY_CONFLICT:
-                return { ...at, kind: 'not_applied', cause: 'idempotency_crossed', ...refusalOf(e) };
+                return { ...at, kind: 'not_applied', cause: 'idempotency_crossed', ...refusalOf(e, reading) };
             case ASK_GONE_PARKED: {
                 const sessionId = readErrorString(obj, 'sessionId');
                 return { ...at, kind: 'not_applied', cause: 'parked', ...(sessionId !== undefined ? { sessionId } : {}) };
@@ -169,15 +115,17 @@ function outcomeOfThrown(e, family, ours, signal, tally, noteCapable) {
                 break;
         }
     }
-    if (status === 404 || status === 410) {
-        return family !== 'ask' && tally.retried ? { ...base, kind: 'unconfirmed', cause: 'gone_after_retry', status } : { ...at, kind: 'not_applied', cause: 'gone' };
-    }
+    if (status === 404 || status === 410)
+        return { ...at, kind: 'not_applied', cause: 'gone' };
     if (status === 501)
         return { ...at, kind: 'not_applied', cause: 'lane_disabled' };
-    return { ...at, kind: 'not_applied', cause: 'refused', ...refusalOf(e) };
+    return { ...at, kind: 'not_applied', cause: 'refused', ...refusalOf(e, reading) };
+}
+function isSafetyStopLayer(layer, reading) {
+    return isLocalSafetyStop(carrierReadOf(layer, reading), reading);
 }
-function refusalOf(e) {
-    const r = classifyDecisionRefusal(e);
+function refusalOf(e, reading) {
+    const r = classifyDeliveredDecisionRefusal(e, reading);
     return r !== undefined ? { refusal: r } : {};
 }
 async function sendApprovalFamily(respond, approvalId, answer, ctx) {
@@ -189,19 +137,29 @@ async function sendApprovalFamily(respond, approvalId, answer, ctx) {
     const ladder = { lastCarried: false, dropped: false, renamed: false };
     const ours = verdictOf(payload.decision);
     const extras = bodyFacts(answer, payload, false);
-    let raw;
-    try {
-        raw = await deliverWithAttributionLadder(body, (b) => withTransportRetry((signal) => respond(approvalId, b, signal !== undefined ? { signal } : undefined), ctx.signal, ctx.tally), ctx.signal, ladder);
-    }
-    catch (e) {
-        return { ...outcomeOfThrown(e, 'approval', ours, ctx.signal, ctx.tally, ctx.noteCapable), ...extras };
-    }
-    const facts = { ...extras, ...(ladder.dropped ? { attributionDropped: true } : {}), ...(ladder.renamed ? { attributionRenamed: true } : {}) };
+    const delivery = await deliverApprovalDecision({
+        approvalId,
+        body,
+        send: (b, signal) => respond(approvalId, b, signal !== undefined ? { signal } : undefined),
+        signal: ctx.signal,
+        tally: ctx.tally,
+        ladder,
+        parkingOf: (raw) => {
+            const p = readToolApprovalRespondParking(raw);
+            return p?.kind === 'parking' ? p.view : undefined;
+        },
+    });
+    const retriedFact = ownReadingSlot(delivery, 'parkingRetried') === true ? { parkingRetried: true } : {};
+    if (delivery.kind === 'thrown')
+        return { ...outcomeOfThrown(delivery.error, 'approval', ours, ctx.signal, ctx.tally, ctx.noteCapable), ...extras, ...retriedFact };
+    const raw = delivery.raw;
+    const facts = { ...extras, ...retriedFact, ...(ladder.dropped ? { attributionDropped: true } : {}), ...(ladder.renamed ? { attributionRenamed: true } : {}) };
     const base = { family: 'approval', attempts: ctx.tally.attempts, ...facts };
     const parking = readToolApprovalRespondParking(raw);
     if (parking !== undefined) {
         const view = parking.kind === 'parking' && parking.view.approvalId === approvalId ? parking.view : undefined;
-        return { ...base, kind: 'not_applied', cause: 'parking', ...(view !== undefined ? { parking: view, ...(view.retryAfterMs !== undefined ? { retryAfterMs: view.retryAfterMs } : {}) } : {}) };
+        const hint = view !== undefined ? ownReadingSlot(view, 'retryAfterMs') : undefined;
+        return { ...base, kind: 'not_applied', cause: 'parking', ...(view !== undefined ? { parking: view, ...(hint !== undefined ? { retryAfterMs: hint } : {}) } : {}) };
     }
     const parsed = readToolApprovalRespondAck(raw);
     if (parsed !== undefined && isToolApprovalRespondReplayed(parsed)) {
@@ -244,13 +202,13 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
     const extras = bodyFacts(req.answer, payload, true);
     const ladder = { lastCarried: false, dropped: false, renamed: false };
     let current = body;
-    const parkingDelay = timingOverride?.parkingDelayMs ?? PARKING_POLL_DELAY_MS;
+    const parkingDelay = deliveryTiming().parkingDelayMs ?? PARKING_POLL_DELAY_MS;
     for (let poll = 0;; poll++) {
         try {
             const raw = await deliverWithAttributionLadder(current, (b) => {
                 current = b;
                 return withTransportRetry((signal) => decideAsk(req.taskId, req.askId, b, signal !== undefined ? { signal } : undefined), ctx.signal, ctx.tally);
-            }, ctx.signal, ladder);
+            }, ctx.signal, ladder, undefined, { kind: 'delivered', readingOf: (thrown) => deliveryReadingOf(thrown, ctx.tally) });
             return {
                 family: 'ask',
                 attempts: ctx.tally.attempts,
@@ -262,14 +220,17 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
             };
         }
         catch (e) {
-            const code = effectiveWireErrorCode(e);
-            const wait = Math.max(parkingDelay * (poll + 1), retryAfterMsOf(e) ?? 0);
-            if (code === ASK_PARKING_RETRY && poll < PARKING_POLL_MAX && !isAborted(ctx.signal) && wait <= PARKING_POLL_WAIT_CAP_MS && !budgetSpent(ctx.tally, wait)) {
+            const settled = settledTransportReadingOf(e, ctx.signal, ctx.tally);
+            const settledAnswer = ownReadingSlot(settled, 'answered');
+            const code = settledAnswer !== undefined ? effectiveCodeOf(settledAnswer.code) : undefined;
+            const wait = Math.max(parkingDelay * (poll + 1), retryAfterMsOf(settledAnswer?.layer ?? e) ?? 0);
+            const safetyStop = settledAnswer !== undefined && isSafetyStopLayer(settledAnswer.layer, settled);
+            if (code === ASK_PARKING_RETRY && !safetyStop && poll < PARKING_POLL_MAX && !isAborted(ctx.signal) && wait <= PARKING_WAIT_CAP_MS && !budgetSpent(ctx.tally, wait)) {
                 await sleepFor(wait, ctx.signal);
                 if (!isAborted(ctx.signal))
                     continue;
             }
-            const out = outcomeOfThrown(e, 'ask', verdict, ctx.signal, ctx.tally, ctx.noteCapable);
+            const out = outcomeOfThrown(e, 'ask', verdict, ctx.signal, ctx.tally, ctx.noteCapable, settled);
             if (out.kind === 'not_applied' && out.cause === 'lane_disabled' && code === ASK_DECISION_LANE_DISABLED && req.approvalId !== undefined) {
                 if (respondForFallback !== undefined && ctx.signal?.aborted !== true) {
                     const fb = await sendApprovalFamily(respondForFallback, req.approvalId, req.answer, ctx);
@@ -303,7 +264,7 @@ function validElicitResponse(r) {
                     const x = readOwnDataValue(v, String(i));
                     if (typeof x !== 'string')
                         return undefined;
-                    copy.push(x);
+                    appendOwnElement(copy, x);
                 }
                 Object.defineProperty(out, k, { value: copy, enumerable: true, writable: true, configurable: true });
             }
@@ -524,7 +485,7 @@ export async function sendHitlDecision(request, deps) {
     const decidedBy = hostField(deps, 'approvalDecidedBy');
     const ctx = {
         signal,
-        tally: { attempts: 0, retried: false, startedAt: Date.now() },
+        tally: newSendTally(),
         noteCapable: hostField(deps, 'approvalDecisionNoteCapable') === true,
         decidedBy: typeof decidedBy === 'object' && decidedBy !== null ? decidedBy : undefined,
     };
@@ -577,3 +538,26 @@ export async function sendHitlDecision(request, deps) {
         ownHold.release(out.kind === 'applied' || out.kind === 'settled_elsewhere' ? 'answered' : undefined);
     return Object.freeze(out);
 }
+export function hitlDecisionOutcomeContent(outcome, lang) {
+    try {
+        if (typeof outcome !== 'object' || outcome === null)
+            return undefined;
+        const kind = readOwnDataValue(outcome, 'kind');
+        if (kind === 'settled_elsewhere') {
+            if (readOwnDataValue(outcome, 'contrary') !== true)
+                return undefined;
+            const first = readOwnDataValue(outcome, 'firstDecision');
+            if (first === 'deny')
+                return renderMessage(msg('approval.decision.settledElsewhereContrary.deniedFirst'), lang);
+            if (first === 'approve')
+                return renderMessage(msg('approval.decision.settledElsewhereContrary.approvedFirst'), lang);
+            return undefined;
+        }
+        if (kind === 'unconfirmed' && readOwnDataValue(outcome, 'cause') === 'gone_after_retry')
+            return renderMessage(msg('approval.decision.unconfirmedAfterRetry'), lang);
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/frameRouter.d.ts

@@ -70,6 +70,7 @@ export interface FrameRouterCtx {
     signal?: AbortSignal | undefined;
 }
 export declare function isAskTool(toolName: string | undefined): boolean;
+export declare function questionCardVerdict(carrier: object | null | undefined): boolean | undefined;
 export declare function parkGateArmOf(gate: unknown): GateKind | null;
 export declare function isHostProgressFrame(ev: AgentEvent): boolean;
 interface HeldFlushInterruptEvidence {

package/dist/hitl/frameRouter.js

@@ -5,6 +5,8 @@ import { classifierDenyFromToolEnd } from '../classifierVerdictWire.js';
 import { toolEndOutputText } from '../toolResultContent.js';
 import { GATE_PARKED_ERROR_CODE } from '../engineErrorCodes.js';
 import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateToolName } from '../runTerminal.js';
+import { readApprovalCardWord } from './approvalCardReading.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from './hitlHostSurface.js';
@@ -102,6 +104,10 @@ function parkFamilyEvidence(led, gateToolName, gatedCallId) {
         return false;
     return gatedCallId === undefined || led.isFsOrShellGatedCall(gatedCallId);
 }
+export function questionCardVerdict(carrier) {
+    const word = readApprovalCardWord(carrier);
+    return word === undefined ? undefined : word === 'question';
+}
 export function parkGateArmOf(gate) {
     if (gate === null || typeof gate !== 'object')
         return null;
@@ -117,7 +123,7 @@ export function parkGateArmOf(gate) {
     const leg = durableDecideLegOf(typeof kind === 'string' ? { gateKind: kind } : null);
     if (leg !== 'approval' && leg !== 'absent')
         return null;
-    if (isAskToolLoose(toolName))
+    if (questionCardVerdict(gate) ?? isAskToolLoose(toolName))
         return 'ask';
     if (leg === 'approval')
         return 'fs';
@@ -147,7 +153,8 @@ function parkGateOf(result) {
     if (typeof taskId !== 'string' || taskId.length === 0)
         return null;
     const toolName = runTerminalGateToolName(read);
-    const arm = parkGateArmOf({ kind: runTerminalGateKind(read), toolName });
+    const approvalCard = guardedRead(() => readOwnDataValue(read.gate, 'approvalCard'));
+    const arm = parkGateArmOf({ kind: runTerminalGateKind(read), toolName, approvalCard });
     return arm === null ? null : { taskId, gate: arm, toolName };
 }
 function parkGatedCallId(src) {