@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/hitl/attributionLadder.d.ts

@@ -1,5 +1,43 @@
-export declare function shouldResendWithoutAttribution(e: {} | null | undefined, sentAttributionKey: boolean, signal?: AbortSignal): boolean;
-export declare function shouldResendUnderSuccessorKey(e: {} | null | undefined, lastSendCarriedRetiredKey: boolean, signal?: AbortSignal): boolean;
+import { type DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
+import { type AnswerCapture, type CapturedLocalCode, type CauseSlotRead, type TopCauseReading, type TopLocalCodeReading, type UnansweredCapture } from '../engineWireFor.js';
+import { type RefusalCarrier, type SafetyStopHead } from './hitlBridge.js';
+import type { SettledFailureReading, TransportClass, TransportReading } from './approvalDelivery.js';
+export interface DeliveredReading {
+    readonly cls?: TransportClass;
+    readonly answered?: AnswerCapture;
+    readonly unanswered?: UnansweredCapture;
+    readonly carrierReads?: readonly {
+        readonly thrown: object;
+        readonly read: RefusalCarrier;
+    }[];
+    readonly topLocalCode?: TopLocalCodeReading;
+    readonly bindingMismatchWrapper?: true;
+    readonly topCause?: TopCauseReading;
+    readonly safetyStop?: true;
+}
+export declare function isLocalSafetyStop(read: RefusalCarrier, reading: DeliveredReading | 'carrier'): boolean;
+export declare function topCauseReadOf(delivered: DeliveredReading | undefined, x: object): CauseSlotRead | undefined;
+export declare function localCodeReadOf(delivered: DeliveredReading | undefined, x: object): {
+    readonly value: CapturedLocalCode;
+} | undefined;
+export declare function carrierReadOf(thrown: {} | null | undefined, delivered: DeliveredReading | undefined): RefusalCarrier;
+export declare function attributionRefusalOfReading(thrown: {} | null | undefined, delivered: DeliveredReading | undefined, sentAttributionKey: boolean): DenyAttributionRefusalDetail | null;
+export declare function attributionRefusalOf(read: RefusalCarrier, reading: DeliveredReading | 'carrier', sentAttributionKey: boolean): DenyAttributionRefusalDetail | null;
+export interface LadderSafetyStop {
+    readonly thrown: object;
+    readonly head: SafetyStopHead;
+    readonly triaged: TransportReading;
+    readonly settled?: SettledFailureReading;
+}
+export type LadderReadingSource = {
+    readonly kind: 'delivered';
+    readonly readingOf: (thrown: {} | null | undefined) => DeliveredReading | undefined;
+} | {
+    readonly kind: 'direct';
+    readonly stopOf: (thrown: {} | null | undefined) => LadderSafetyStop | undefined;
+};
+export declare function shouldResendWithoutAttribution(refusal: DenyAttributionRefusalDetail | null, sentAttributionKey: boolean, signal?: AbortSignal): boolean;
+export declare function shouldResendUnderSuccessorKey(refusal: DenyAttributionRefusalDetail | null, lastSendCarriedRetiredKey: boolean, signal?: AbortSignal): boolean;
 export declare function carriesAttributionKey(body: object): boolean;
 export declare function withoutAttributionKey<T extends {
     settledBy?: unknown;
@@ -15,9 +53,10 @@ export interface AttributionLadderState {
     lastCarried: boolean;
     dropped: boolean;
     renamed: boolean;
+    safetyStop?: LadderSafetyStop | undefined;
 }
 export type AttributionLadderStep = 'dropped' | 'renamed' | 'renamed_then_dropped';
 export declare function deliverWithAttributionLadder<B extends {
     settledBy?: unknown;
     decidedBy?: unknown;
-}, R>(body: B, send: (b: B) => Promise<R>, signal: AbortSignal | undefined, state: AttributionLadderState, onStep?: (step: AttributionLadderStep) => void): Promise<R>;
+}, R>(body: B, send: (b: B) => Promise<R>, signal: AbortSignal | undefined, state: AttributionLadderState, onStep: ((step: AttributionLadderStep) => void) | undefined, source: LadderReadingSource): Promise<R>;

package/dist/hitl/attributionLadder.js

@@ -1,17 +1,86 @@
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
-export function shouldResendWithoutAttribution(e, sentAttributionKey, signal) {
+import { ownReadingSlot } from '../engineWireFor.js';
+import { guardedRead } from '../ownKey.js';
+import { isSlotCarrier, readRefusalField } from '../wireFailureShape.js';
+import { refusalCarrierOf } from './hitlBridge.js';
+export function isLocalSafetyStop(read, reading) {
+    if (reading !== 'carrier' && ownReadingSlot(reading, 'safetyStop') === true)
+        return true;
+    return ownReadingSlot(read, 'local') !== undefined;
+}
+export function topCauseReadOf(delivered, x) {
+    const t = ownReadingSlot(delivered, 'topCause');
+    return t !== undefined && t.layer === x ? t.read : undefined;
+}
+export function localCodeReadOf(delivered, x) {
+    const a = ownReadingSlot(delivered, 'answered');
+    if (a !== undefined && a.layer === x)
+        return { value: a.localCode };
+    const u = ownReadingSlot(delivered, 'unanswered');
+    if (u !== undefined && u.layer === x)
+        return { value: u.localCode };
+    const t = ownReadingSlot(delivered, 'topLocalCode');
+    return t !== undefined && t.layer === x ? { value: t.localCode } : undefined;
+}
+function bindingMismatchWrapperOver(thrown, delivered) {
+    return ownReadingSlot(delivered, 'bindingMismatchWrapper') === true && ownReadingSlot(delivered, 'answered')?.layer === thrown;
+}
+export function carrierReadOf(thrown, delivered) {
+    const read = recordedCarrierReadOf(thrown, delivered);
+    if (!bindingMismatchWrapperOver(thrown, delivered) || ownReadingSlot(read, 'local') === 'binding_mismatch')
+        return read;
+    return Object.freeze({ carrier: read.carrier, local: 'binding_mismatch' });
+}
+function recordedCarrierReadOf(thrown, delivered) {
+    const list = ownReadingSlot(delivered, 'carrierReads');
+    if (list !== undefined) {
+        for (let i = 0; i < list.length; i++) {
+            const c = list[i];
+            if (c !== undefined && c.thrown === thrown)
+                return c.read;
+        }
+    }
+    return isSlotCarrier(thrown) ? refusalCarrierOf(thrown, localCodeReadOf(delivered, thrown), false, topCauseReadOf(delivered, thrown)) : refusalCarrierOf(thrown);
+}
+export function attributionRefusalOfReading(thrown, delivered, sentAttributionKey) {
+    if (delivered === undefined)
+        return null;
+    return attributionRefusalOf(carrierReadOf(thrown, delivered), delivered, sentAttributionKey);
+}
+export function attributionRefusalOf(read, reading, sentAttributionKey) {
+    if (isLocalSafetyStop(read, reading))
+        return null;
+    if (reading === 'carrier')
+        return denyAttributionRefusalFromError(read.carrier, sentAttributionKey);
+    const delivered = reading;
+    const a = ownReadingSlot(delivered, 'answered');
+    if (a === undefined || a.layer !== read.carrier || a.code.state !== 'read' || a.code.wire === undefined)
+        return null;
+    const field = guardedRead(() => readRefusalField(a.layer));
+    return denyAttributionRefusalFromError(Object.freeze({ status: a.status, errorCode: a.code.wire, ...(field !== undefined ? { field } : {}) }), sentAttributionKey);
+}
+function ladderRefusalOf(thrown, source, state) {
+    if (source.kind === 'delivered')
+        return attributionRefusalOfReading(thrown, source.readingOf(thrown), true);
+    const stop = source.stopOf(thrown);
+    if (stop === undefined)
+        return attributionRefusalOf({ carrier: thrown }, 'carrier', true);
+    state.safetyStop = stop;
+    return attributionRefusalOf(stop.head.local !== undefined ? { carrier: thrown, local: stop.head.local } : { carrier: thrown }, stop.triaged, true);
+}
+export function shouldResendWithoutAttribution(refusal, sentAttributionKey, signal) {
     if (!sentAttributionKey)
         return false;
     if (signal?.aborted === true)
         return false;
-    return denyAttributionRefusalFromError(e, true)?.kind === 'not_in_proof';
+    return refusal?.kind === 'not_in_proof';
 }
-export function shouldResendUnderSuccessorKey(e, lastSendCarriedRetiredKey, signal) {
+export function shouldResendUnderSuccessorKey(refusal, lastSendCarriedRetiredKey, signal) {
     if (!lastSendCarriedRetiredKey)
         return false;
     if (signal?.aborted === true)
         return false;
-    return denyAttributionRefusalFromError(e, true)?.kind === 'retired_key';
+    return refusal?.kind === 'retired_key';
 }
 export function carriesAttributionKey(body) {
     return Object.hasOwn(body, 'settledBy') || Object.hasOwn(body, 'decidedBy');
@@ -27,15 +96,17 @@ export function withAttributionKeyRenamed(body) {
     void _replaced;
     return settledBy === undefined ? rest : { ...rest, decidedBy: settledBy };
 }
-export async function deliverWithAttributionLadder(body, send, signal, state, onStep) {
+export async function deliverWithAttributionLadder(body, send, signal, state, onStep, source) {
     state.lastCarried = carriesAttributionKey(body);
     state.dropped = false;
     state.renamed = false;
+    state.safetyStop = undefined;
     try {
         return await send(body);
     }
     catch (first) {
-        if (shouldResendWithoutAttribution(first, state.lastCarried, signal)) {
+        const firstRefusal = ladderRefusalOf(first, source, state);
+        if (shouldResendWithoutAttribution(firstRefusal, state.lastCarried, signal)) {
             const withoutAttribution = withoutAttributionKey(body);
             state.lastCarried = false;
             onStep?.('dropped');
@@ -43,7 +114,7 @@ export async function deliverWithAttributionLadder(body, send, signal, state, on
             state.dropped = true;
             return r;
         }
-        if (shouldResendUnderSuccessorKey(first, Object.hasOwn(body, 'settledBy'), signal)) {
+        if (shouldResendUnderSuccessorKey(firstRefusal, Object.hasOwn(body, 'settledBy'), signal)) {
             const renamed = withAttributionKeyRenamed(body);
             onStep?.('renamed');
             try {
@@ -52,7 +123,7 @@ export async function deliverWithAttributionLadder(body, send, signal, state, on
                 return r;
             }
             catch (second) {
-                if (!shouldResendWithoutAttribution(second, true, signal))
+                if (!shouldResendWithoutAttribution(ladderRefusalOf(second, source, state), true, signal))
                     throw second;
                 const renamedWithoutAttribution = withoutAttributionKey(renamed);
                 state.lastCarried = false;

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -20,9 +20,14 @@ export type AutomaticAnswerVerdict = {
     readonly kind: 'unknown';
     readonly why: AutomaticAnswerUnknownWhy;
 };
-export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "target_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "target_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
 export declare function foldModeArbitrationRow(classes: Iterable<string>, askFace?: AutomaticAnswerAskFace): CoreModeArbitrationRow;
 export declare function automaticAnswerVerdict(card: object | null | undefined, lane: AutomaticAnswerLane, facts?: AutomaticAnswerFacts | null): AutomaticAnswerVerdict;
 export declare function mandatedApprovalDetailOf(card: object | null | undefined, lang?: UiLanguage): string;
+export interface CrossBoundaryTaintReading {
+    readonly taint: true;
+}
+export declare function crossBoundaryTaintOf(carrier: object | null | undefined): CrossBoundaryTaintReading | undefined;
+export declare function crossBoundaryTaintWayOutOf(carrier: object | null | undefined, lang?: UiLanguage): string | undefined;
 export type PermissionRequestHookScope = 'allow_or_deny' | 'deny_only' | 'skip';
 export declare function permissionRequestHookScope(verdict: AutomaticAnswerVerdict | null | undefined): PermissionRequestHookScope;

package/dist/hitl/automaticAnswerVerdict.js

@@ -2,7 +2,7 @@ import { CORE_MODE_ARBITRATION, CORE_MODE_RELEASE_REASONS } from '../generated/e
 import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from '../generated/engineAskFaceTables.js';
 import { mandatedApprovalDetail } from '../gateVocabulary.js';
 import { msg, renderMessage } from '../i18n/translate.js';
-import { readAskOrigin, readOwnNonEmptyString } from '../ownKey.js';
+import { guardedRead, readAskOrigin, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPairState } from './askClassPair.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
 import { approvalAllowRuleShadowed, retiredAllowRuleShadowKeyPresent } from './allowRuleShadow.js';
@@ -31,7 +31,7 @@ function bypassImmuneOn(c, face) {
 function askFaceOfCard(card) {
     try {
         const d = Object.getOwnPropertyDescriptor(card, 'toolName');
-        return d !== undefined && 'value' in d && typeof d.value === 'string' && CORE_SHELL_FACE_TOOL_NAMES.includes(d.value) ? 'shell' : 'other';
+        return d !== undefined && Object.hasOwn(d, 'value') && typeof d.value === 'string' && CORE_SHELL_FACE_TOOL_NAMES.includes(d.value) ? 'shell' : 'other';
     }
     catch {
         return 'other';
@@ -61,11 +61,11 @@ export function foldModeArbitrationRow(classes, askFace) {
     return Object.freeze({ bypassImmune, classifierEligible, sandboxAdmission, ruleMayClear, hookAskFloor });
 }
 function rowBlocks(lane, row) {
-    return lane === 'mode_posture' ? row.bypassImmune : lane === 'standing_rule' ? !row.ruleMayClear : row.hookAskFloor;
+    return lane === 'mode_posture' ? row.bypassImmune : !row.ruleMayClear;
 }
 function classBlocks(lane, c, face) {
     const row = TABLE[c];
-    return lane === 'mode_posture' ? bypassImmuneOn(c, face) : lane === 'standing_rule' ? !row.ruleMayClear : row.hookAskFloor;
+    return lane === 'mode_posture' ? bypassImmuneOn(c, face) : !row.ruleMayClear;
 }
 function mustAsk(road, extra) {
     return Object.freeze({ kind: 'must_ask', road, ...(extra?.askClass !== undefined ? { askClass: extra.askClass } : {}), ...(extra?.origin !== undefined ? { origin: extra.origin } : {}) });
@@ -91,13 +91,8 @@ function evidenceView(card, ...keys) {
 function readHostAskRuleMatched(facts) {
     if (typeof facts !== 'object' || facts === null)
         return undefined;
-    try {
-        const d = Object.getOwnPropertyDescriptor(facts, 'settingsAskRuleMatched');
-        return d !== undefined && 'value' in d && typeof d.value === 'boolean' ? d.value : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    const v = guardedRead(() => readOwnDataValue(facts, 'settingsAskRuleMatched'));
+    return typeof v === 'boolean' ? v : undefined;
 }
 export function automaticAnswerVerdict(card, lane, facts) {
     if (lane !== 'mode_posture' && lane !== 'standing_rule' && lane !== 'permission_request_hook')
@@ -199,6 +194,46 @@ export function mandatedApprovalDetailOf(card, lang) {
         return mandatedApprovalDetail(lang);
     }
 }
+const CROSS_BOUNDARY_CLASS = 'cross_boundary';
+const CROSS_BOUNDARY_MANDATE = 'cross_boundary_taint';
+const TAINTED = Object.freeze({ taint: true });
+function snapshotOf(carrier) {
+    const out = {};
+    for (const key of ['mandate', 'askClass', 'classes']) {
+        const v = guardedRead(() => readOwnDataValue(carrier, key));
+        if (v !== undefined)
+            out[key] = v;
+    }
+    return out;
+}
+function classEvidence(carrier) {
+    try {
+        const pair = readAskClassPairState(carrier);
+        return pair.state === 'pair' && pair.classes.includes(CROSS_BOUNDARY_CLASS) ? true : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mandateEvidence(carrier) {
+    return readApprovalMandate(carrier) === CROSS_BOUNDARY_MANDATE ? true : undefined;
+}
+export function crossBoundaryTaintOf(carrier) {
+    if (typeof carrier !== 'object' || carrier === null)
+        return undefined;
+    const snapshot = snapshotOf(carrier);
+    return classEvidence(snapshot) === true || mandateEvidence(snapshot) === true ? TAINTED : undefined;
+}
+export function crossBoundaryTaintWayOutOf(carrier, lang) {
+    try {
+        if (crossBoundaryTaintOf(carrier) === undefined)
+            return undefined;
+        return renderMessage(msg('approval.mandate.wayOut.crossBoundaryTaint'), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function permissionRequestHookScope(verdict) {
     try {
         const kind = typeof verdict === 'object' && verdict !== null ? verdict.kind : undefined;

package/dist/hitl/crashConverged.js

@@ -10,7 +10,7 @@ const isNumber = (v) => typeof v === 'number';
 const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;
 const ownDataValue = (obj, key) => {
     const d = Object.getOwnPropertyDescriptor(obj, key);
-    if (d === undefined || 'get' in d || 'set' in d)
+    if (d === undefined || Object.hasOwn(d, 'get') || Object.hasOwn(d, 'set'))
         return undefined;
     return d.value;
 };
@@ -30,7 +30,7 @@ function readCrashConvergedRow(v) {
             const d = descs[k];
             if (d === undefined || d.enumerable !== true)
                 continue;
-            if ('get' in d || 'set' in d) {
+            if (Object.hasOwn(d, 'get') || Object.hasOwn(d, 'set')) {
                 unstable = true;
                 continue;
             }

package/dist/hitl/decisionConflict.d.ts

@@ -1,3 +1,7 @@
-export type DecisionRefusalConflict = 'binding_mismatch' | 'row_integrity' | 'format_version' | 'answer_invalid';
-export declare function decisionConflictOf(err: unknown): DecisionRefusalConflict | undefined;
+import type { UiLanguage } from '../env/uiLanguage.js';
+import type { CapturedCode } from '../engineWireFor.js';
+import { type ProtocolErrorNameReading } from '../wireFailureShape.js';
+export type DecisionRefusalConflict = 'binding_mismatch' | 'row_integrity' | 'format_version' | 'answer_invalid' | 'grant_changed';
+export declare function decisionConflictOf(err: unknown, captured?: CapturedCode, protocolNameRead?: ProtocolErrorNameReading): DecisionRefusalConflict | undefined;
 export declare const DECISION_ANSWER_INVALID_CONTENT = "The engine rejected the answer itself because it does not fit the question that was asked \u00B7 Nothing was decided and the question is still waiting \u00B7 Correct the answer and send it again";
+export declare function decisionGrantChangedContent(lang?: UiLanguage): string;

package/dist/hitl/decisionConflict.js

@@ -1,19 +1,31 @@
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { ownDataField } from '../ownKey.js';
-import { PROTOCOL_ERROR_NAME, protocolErrorNameOf, readRefusalField } from '../wireFailureShape.js';
+import { isSlotCarrier, PROTOCOL_ERROR_NAME, protocolErrorNameOf, readRefusalField } from '../wireFailureShape.js';
 const BINDING_SEAT_FIELDS = new Set(['boundCallId', 'boundInputHash']);
 const ANSWER_FIELD = 'answer';
-export function decisionConflictOf(err) {
-    if (typeof err !== 'object' || err === null)
+const GRANT_DIGEST_FIELD = 'boundGrantDigest';
+function namedProtocolOf(r) {
+    return r.state === 'named' ? r.name : undefined;
+}
+export function decisionConflictOf(err, captured, protocolNameRead) {
+    if (!isSlotCarrier(err))
         return undefined;
     let code;
-    try {
-        code = ownDataField(err, 'errorCode');
+    if (captured !== undefined) {
+        if (captured.state !== 'read')
+            return undefined;
+        code = captured.wire;
     }
-    catch {
-        return undefined;
+    else {
+        try {
+            code = ownDataField(err, 'errorCode');
+        }
+        catch {
+            return undefined;
+        }
     }
-    const protocolName = protocolErrorNameOf(err);
+    const protocolName = protocolNameRead !== undefined ? namedProtocolOf(protocolNameRead) : protocolErrorNameOf(err);
     if (code === CHECKPOINT_UNSUPPORTED_VERSION)
         return 'format_version';
     const bindingFamily = code === APPROVAL_BINDING_MISMATCH || (code === undefined && protocolName === PROTOCOL_ERROR_NAME.ApprovalBindingMismatchError);
@@ -27,9 +39,12 @@ export function decisionConflictOf(err) {
         field = undefined;
     }
     if (code === RESUME_OUTCOME_INVALID)
-        return field === ANSWER_FIELD ? 'answer_invalid' : undefined;
+        return field === ANSWER_FIELD ? 'answer_invalid' : field === GRANT_DIGEST_FIELD ? 'grant_changed' : undefined;
     if (field === undefined)
         return 'row_integrity';
     return BINDING_SEAT_FIELDS.has(field) ? 'binding_mismatch' : undefined;
 }
 export const DECISION_ANSWER_INVALID_CONTENT = 'The engine rejected the answer itself because it does not fit the question that was asked · Nothing was decided and the question is still waiting · Correct the answer and send it again';
+export function decisionGrantChangedContent(lang) {
+    return renderMessage(msg('approval.decision.grantChanged'), lang);
+}

package/dist/hitl/decisionRefusal.d.ts

@@ -1,24 +1,30 @@
-import { type GateCurrentPending, type HitlSafetyCode } from './hitlBridge.js';
+import { type UiLanguage } from '../env/uiLanguage.js';
+import { type GateCurrentPending, type RefusalCarrier } from './hitlBridge.js';
 import { type DecisionRefusalConflict } from './decisionConflict.js';
-import { type ProtocolErrorName } from '../wireFailureShape.js';
-import { type DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
+import { type ProtocolErrorName, type ProtocolErrorNameReading } from '../wireFailureShape.js';
+import type { DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
+import { type DeliveredReading } from './attributionLadder.js';
+import { type AnswerCapture, type UnansweredCapture } from '../engineWireFor.js';
 export declare const ASK_DECIDED_CODE = "conflict.ask_decided";
 export type DecisionRefusalStanding = 'settled-elsewhere' | 'ambiguous' | 'refused-pending';
 export type { DecisionRefusalConflict } from './decisionConflict.js';
-export interface RefusalCarrier {
-    readonly local?: HitlSafetyCode;
-    readonly carrier: {} | null | undefined;
+export { refusalCarrierOf, type RefusalCarrier } from './hitlBridge.js';
+declare const DELIVERED_UNREADABLE: unique symbol;
+type DeliveredAnswer = AnswerCapture | UnansweredCapture | typeof DELIVERED_UNREADABLE;
+interface CarrierRead extends RefusalCarrier {
+    readonly protocolName: ProtocolErrorNameReading;
 }
-export declare function refusalCarrierOf(err: {} | null | undefined): RefusalCarrier;
 export interface RefusalRouteContext {
     readonly route?: 'approval_decide' | 'live_respond' | 'ask_decide' | 'plan_review' | 'compact';
+    readonly afterRetry?: true;
 }
+export declare function notPendingAfterRetry(status: number | undefined, retried: boolean): boolean;
 export interface RefusalDelivery {
     readonly delivery: 'refused' | 'ambiguous' | 'no_answer';
     readonly status?: number;
     readonly errorCode?: string;
 }
-export declare function refusalDeliveryOf(err: {} | null | undefined, context?: RefusalRouteContext): RefusalDelivery;
+export declare function refusalDeliveryOf(err: {} | null | undefined, context?: RefusalRouteContext, answer?: DeliveredAnswer, read?: RefusalCarrier): RefusalDelivery;
 export declare function decisionRefusalSaysAskGone(err: unknown): boolean;
 export type DecisionRefusalAskReading = 'settled' | 'not_settled' | 'unreadable';
 interface DecisionRefusalAskFacts {
@@ -26,7 +32,7 @@ interface DecisionRefusalAskFacts {
     readonly gateMoved: boolean;
     readonly wordingHint: boolean;
 }
-export declare function readDecisionRefusalAsk(failure: unknown): DecisionRefusalAskFacts;
+export declare function readDecisionRefusalAsk(failure: unknown, answer?: DeliveredAnswer, read?: CarrierRead): DecisionRefusalAskFacts;
 export declare function decisionRefusalAskReading(failure: unknown): DecisionRefusalAskReading;
 export interface DecisionRefusalReading {
     readonly status?: number;
@@ -47,8 +53,9 @@ export interface DecisionRefusalReading {
     readonly standing?: DecisionRefusalStanding;
     readonly transient?: true;
     readonly conflict?: DecisionRefusalConflict;
+    readonly unrecoverable?: true;
 }
-export declare function mintDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext, attributionCarried?: boolean): DecisionRefusalReading;
+export declare function mintDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext, attributionCarried?: boolean, delivered?: DeliveredReading, carried?: RefusalCarrier): DecisionRefusalReading;
 export declare function readDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext): DecisionRefusalReading;
 export interface DecisionRefusalClassified {
     readonly standing: DecisionRefusalStanding;
@@ -56,8 +63,10 @@ export interface DecisionRefusalClassified {
     readonly errorCode?: string;
     readonly transient?: true;
     readonly conflict?: DecisionRefusalConflict;
+    readonly unrecoverable?: true;
 }
 export declare function classifyDecisionRefusal(err: unknown, context?: RefusalRouteContext): DecisionRefusalClassified | undefined;
+export declare function classifyDeliveredDecisionRefusal(err: {} | null | undefined, delivered: DeliveredReading): DecisionRefusalClassified | undefined;
 export type LiveAskPendingReading = 'pending' | 'not_pending' | 'unknown';
 export declare function liveAskPendingReading(envelope: unknown, approvalId: string): LiveAskPendingReading;
 export declare function decisionRefusalClosesOut(refusal: DecisionRefusalClassified | undefined, pending: LiveAskPendingReading): boolean;
@@ -69,3 +78,4 @@ export interface UndeliverableDecisionFacts {
     readonly runId?: string;
 }
 export declare function undeliverableDecisionContent(facts: UndeliverableDecisionFacts): string;
+export declare function decideRowUnrevivableNotice(lang?: UiLanguage | (string & {})): string;