@sema-agent/client-core 0.99.0 → 0.101.0

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/decisionLedger.d.ts

@@ -0,0 +1,55 @@
+export declare const DECISION_LEDGER_FAMILIES: readonly ["plan_review", "tool_approval", "elicitation"];
+export type DecisionLedgerFamily = (typeof DECISION_LEDGER_FAMILIES)[number];
+export type DecisionLedgerPhase = 'handed' | 'posting' | 'landed';
+export type DecisionLedgerSettler = 'host' | 'package' | 'gate_left';
+export interface DecisionLedgerOp {
+    readonly family: DecisionLedgerFamily;
+    keys: readonly string[];
+    readonly handedAt: number;
+    settledAt: number | null;
+    settler: DecisionLedgerSettler | null;
+    phase: DecisionLedgerPhase;
+    notApplied: boolean;
+    ownCallOpen: boolean;
+}
+export interface DecisionLedgerIdentityParts {
+    readonly taskId?: string | undefined;
+    readonly planTaskId?: string | undefined;
+    readonly approvalId?: string | undefined;
+    readonly callId?: string | undefined;
+    readonly askId?: string | undefined;
+    readonly elicitationId?: string | undefined;
+}
+export declare function decisionLedgerKeysOf(parts: DecisionLedgerIdentityParts): string[];
+export declare function planDecisionKey(taskId: string): string;
+export declare function nextDecisionLedgerTick(): number;
+export declare function decisionOpsWithKey(family: DecisionLedgerFamily, key: string): DecisionLedgerOp[];
+export declare function decisionOpsOfFamily(family: DecisionLedgerFamily): readonly DecisionLedgerOp[];
+export declare function openDecisionOp(family: DecisionLedgerFamily, keys: readonly string[], phase: DecisionLedgerPhase, ownCallOpen: boolean): DecisionLedgerOp;
+export declare function settleDecisionOp(op: DecisionLedgerOp, by: DecisionLedgerSettler): void;
+export declare function closeDecisionOp(op: DecisionLedgerOp, by: DecisionLedgerSettler): void;
+export declare function addDecisionOpKeys(op: DecisionLedgerOp, keys: readonly string[]): void;
+export declare function dropDecisionOp(op: DecisionLedgerOp): void;
+export declare function markLatestDecisionNotApplied(family: DecisionLedgerFamily, key: string): void;
+export declare function settleDecisionOpsOnGateLeft(family: DecisionLedgerFamily, key: string): void;
+export declare function latestDecisionHandedMark(family: DecisionLedgerFamily, key: string): number | null;
+export declare function readMarkOf(v: number | undefined): number | undefined;
+export declare function decisionKeyInFlight(key: string, mark: number | undefined): boolean;
+export type DecisionIdentity = {
+    readonly gate: 'plan_review';
+    readonly taskId: string;
+} | {
+    readonly gate: 'tool_approval';
+    readonly approvalId?: string;
+    readonly callId?: string;
+    readonly askId?: string;
+} | {
+    readonly gate: 'elicitation';
+    readonly elicitationId: string;
+} | {
+    readonly gate: 'run';
+    readonly taskId: string;
+};
+export declare function decisionInFlightOf(identity: DecisionIdentity, readMark?: number): boolean;
+export declare function decisionReadMark(): number;
+export declare function __resetDecisionLedgerForTests(family?: DecisionLedgerFamily): void;

package/dist/hitl/decisionLedger.js

@@ -0,0 +1,156 @@
+import { guardedRead, readOwnDataNonEmptyString } from '../ownKey.js';
+export const DECISION_LEDGER_FAMILIES = Object.freeze(['plan_review', 'tool_approval', 'elicitation']);
+const FAMILY_CAPACITY = Object.freeze({ plan_review: 32, tool_approval: 64, elicitation: 64 });
+const KEY_PREFIX = Object.freeze({ run: 'run\u0000', plan: 'plan\u0000', approval: 'approval\u0000', call: 'call\u0000', ask: 'ask\u0000', elicitation: 'elicitation\u0000' });
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+export function decisionLedgerKeysOf(parts) {
+    const out = [];
+    const add = (prefix, v) => {
+        if (nonEmpty(v) && !out.includes(prefix + v))
+            out.push(prefix + v);
+    };
+    add(KEY_PREFIX.run, parts.taskId);
+    add(KEY_PREFIX.plan, parts.planTaskId);
+    add(KEY_PREFIX.approval, parts.approvalId);
+    add(KEY_PREFIX.call, parts.callId);
+    add(KEY_PREFIX.ask, parts.askId);
+    add(KEY_PREFIX.elicitation, parts.elicitationId);
+    return out;
+}
+export function planDecisionKey(taskId) {
+    return KEY_PREFIX.plan + taskId;
+}
+const ledger = Object.freeze({ plan_review: [], tool_approval: [], elicitation: [] });
+let ledgerClock = 0;
+export function nextDecisionLedgerTick() {
+    return ++ledgerClock;
+}
+export function decisionOpsWithKey(family, key) {
+    return ledger[family].filter((op) => op.keys.includes(key));
+}
+export function decisionOpsOfFamily(family) {
+    return ledger[family];
+}
+export function openDecisionOp(family, keys, phase, ownCallOpen) {
+    const op = {
+        family,
+        keys: Object.freeze([...keys]),
+        handedAt: ++ledgerClock,
+        settledAt: null,
+        settler: null,
+        phase,
+        notApplied: false,
+        ownCallOpen,
+    };
+    const rows = ledger[family];
+    rows.push(op);
+    while (rows.length > FAMILY_CAPACITY[family]) {
+        let victim = rows.findIndex((o) => o.settledAt !== null && !o.ownCallOpen);
+        if (victim < 0)
+            victim = rows.findIndex((o) => o !== op && o.phase === 'handed' && !o.ownCallOpen);
+        if (victim < 0)
+            break;
+        rows.splice(victim, 1);
+    }
+    return op;
+}
+export function settleDecisionOp(op, by) {
+    if (op.settledAt !== null)
+        return;
+    op.settledAt = ++ledgerClock;
+    op.settler = by;
+}
+export function closeDecisionOp(op, by) {
+    if (op.phase === 'posting')
+        op.phase = 'landed';
+    settleDecisionOp(op, by);
+    op.ownCallOpen = false;
+}
+export function addDecisionOpKeys(op, keys) {
+    const extra = keys.filter((k) => !op.keys.includes(k));
+    if (extra.length > 0)
+        op.keys = Object.freeze([...op.keys, ...extra]);
+}
+export function dropDecisionOp(op) {
+    const rows = ledger[op.family];
+    const i = rows.indexOf(op);
+    if (i >= 0)
+        rows.splice(i, 1);
+}
+export function markLatestDecisionNotApplied(family, key) {
+    const ops = decisionOpsWithKey(family, key);
+    if (ops.some((op) => op.settledAt === null))
+        return;
+    let latest;
+    for (const op of ops)
+        if (latest === undefined || op.handedAt > latest.handedAt)
+            latest = op;
+    if (latest !== undefined)
+        latest.notApplied = true;
+}
+export function settleDecisionOpsOnGateLeft(family, key) {
+    for (const op of decisionOpsWithKey(family, key))
+        settleDecisionOp(op, 'gate_left');
+}
+export function latestDecisionHandedMark(family, key) {
+    let mark = null;
+    for (const op of decisionOpsWithKey(family, key))
+        if (mark === null || op.handedAt > mark)
+            mark = op.handedAt;
+    return mark;
+}
+function anyInFlight(keys, mark) {
+    if (keys.length === 0)
+        return false;
+    for (const family of DECISION_LEDGER_FAMILIES) {
+        for (const op of ledger[family]) {
+            if (!op.keys.some((k) => keys.includes(k)))
+                continue;
+            if (op.settledAt === null)
+                return true;
+            if (mark !== undefined && op.settledAt > mark && !op.notApplied)
+                return true;
+        }
+    }
+    return false;
+}
+export function readMarkOf(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
+export function decisionKeyInFlight(key, mark) {
+    return anyInFlight([key], mark);
+}
+function queryKeysOf(identity) {
+    if (typeof identity !== 'object' || identity === null)
+        return [];
+    const gate = guardedRead(() => readOwnDataNonEmptyString(identity, 'gate'));
+    const s = (key) => guardedRead(() => readOwnDataNonEmptyString(identity, key));
+    switch (gate) {
+        case 'plan_review':
+            return decisionLedgerKeysOf({ planTaskId: s('taskId') });
+        case 'run':
+            return decisionLedgerKeysOf({ taskId: s('taskId') });
+        case 'tool_approval':
+            return decisionLedgerKeysOf({ approvalId: s('approvalId'), callId: s('callId'), askId: s('askId') });
+        case 'elicitation':
+            return decisionLedgerKeysOf({ elicitationId: s('elicitationId') });
+        default:
+            return [];
+    }
+}
+export function decisionInFlightOf(identity, readMark) {
+    try {
+        return anyInFlight(queryKeysOf(identity), readMarkOf(readMark));
+    }
+    catch {
+        return false;
+    }
+}
+export function decisionReadMark() {
+    return ++ledgerClock;
+}
+export function __resetDecisionLedgerForTests(family) {
+    for (const f of DECISION_LEDGER_FAMILIES)
+        if (family === undefined || f === family)
+            ledger[f].length = 0;
+}

package/dist/hitl/decisionRefusal.d.ts

@@ -1,23 +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 {
@@ -25,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;
@@ -46,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;
@@ -55,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;
@@ -68,3 +78,4 @@ export interface UndeliverableDecisionFacts {
     readonly runId?: string;
 }
 export declare function undeliverableDecisionContent(facts: UndeliverableDecisionFacts): string;
+export declare function decideRowUnrevivableNotice(lang?: UiLanguage | (string & {})): string;

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';
-const ASK_DECIDED_CODE = 'conflict.ask_decided';
+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);
+}