@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/hitl/approvalResolution.js

@@ -1,6 +1,9 @@
-import { DecideTransportRetryExhaustedError } from './hitlBridge.js';
-import { mintDecisionRefusalReading, refusalCarrierOf } from './decisionRefusal.js';
-import { thrownIsInstanceOf } from '../wireFailureShape.js';
+import { DecideTransportRetryExhaustedError, refusalCarrierOf, safetyStopHeadOf, safetyStopNamed } from './hitlBridge.js';
+import { mintDecisionRefusalReading } from './decisionRefusal.js';
+import { isSlotCarrier, thrownIsInstanceOf } from '../wireFailureShape.js';
+import { carrierReadOf, isLocalSafetyStop, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
+import { directFailureReadingOf, transportReadingOf } from './approvalDelivery.js';
+import { ownReadingSlot } from '../engineWireFor.js';
 export const APPROVAL_RESOLUTION_LANES = Object.freeze(['respond', 'decide', 'ask']);
 export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'retracted',
@@ -91,29 +94,65 @@ export function approvalResolutionDetail(r) {
     return parts.length > 0 ? parts.join(' · ') : undefined;
 }
 export function unsettledCauseOfReading(reading) {
-    if (reading.standing === 'ambiguous')
+    const standing = ownReadingSlot(reading, 'standing');
+    if (standing === 'ambiguous')
         return 'engine_error';
-    return reading.standing === undefined ? 'no_answer' : 'engine_refused';
+    return standing === undefined ? 'no_answer' : 'engine_refused';
 }
 export function resolutionOfDecisionFailure(e, m) {
+    const gatedCallId = ownReadingSlot(m, 'gatedCallId');
     const base = {
         lane: m.lane,
-        ...(m.gatedCallId !== undefined ? { gatedCallId: m.gatedCallId } : {}),
+        ...(gatedCallId !== undefined ? { gatedCallId } : {}),
     };
-    const detail = m.detail !== undefined && m.detail.length > 0 ? { detail: m.detail } : {};
-    const { local } = refusalCarrierOf(e);
-    if (local !== undefined && local !== 'binding_mismatch') {
+    const mDetail = ownReadingSlot(m, 'detail');
+    const detail = mDetail !== undefined && mDetail.length > 0 ? { detail: mDetail } : {};
+    const delivered = ownReadingSlot(m, 'delivered');
+    const handed = ownReadingSlot(m, 'directStop');
+    const stop = delivered !== undefined ? undefined : handed !== undefined && handed.thrown === e ? handed : directSafetyStopOf(e);
+    const triaged = stop?.triaged;
+    const head = delivered !== undefined ? undefined : stop !== undefined ? stop.head : { named: false };
+    const direct = stop !== undefined && stop.head.local !== undefined ? (ownReadingSlot(stop, 'settled') ?? directFailureReadingOf(e, stop.triaged, stop.head)) : undefined;
+    const subject = direct !== undefined ? direct.thrown : e;
+    const reading = delivered ?? direct?.reading;
+    const carrierRead = reading !== undefined ? carrierReadOf(subject, reading) : refusalCarrierOf(e, undefined, false, triaged !== undefined && isSlotCarrier(e) ? topCauseReadOf(triaged, e) : undefined, head);
+    const local = ownReadingSlot(carrierRead, 'local');
+    if (local !== undefined && local !== 'binding_mismatch' && zeroByteProven(subject, reading, delivered !== undefined, ownReadingSlot(m, 'afterRetry') === true)) {
         if (local === 'no_pending' || local === 'wrong_gate')
             return { kind: 'not_sent', ...base, cause: local, ...detail };
         return { kind: 'not_sent', ...base, cause: 'safety_stop', safetyCode: local, ...detail };
     }
-    const refusal = mintDecisionRefusalReading(e, { route: m.route }, m.attributionCarried);
+    const refusal = mintDecisionRefusalReading(subject, { route: m.route, ...(ownReadingSlot(m, 'afterRetry') === true ? { afterRetry: true } : {}) }, ownReadingSlot(m, 'attributionCarried'), reading, carrierRead);
     if (local === 'binding_mismatch')
         return { kind: 'unsettled', ...base, cause: 'engine_refused', safetyCode: 'binding_mismatch', refusal, ...detail };
-    if (thrownIsInstanceOf(e, DecideTransportRetryExhaustedError))
+    if (ownReadingSlot(m, 'transportExhausted') === true || thrownIsInstanceOf(e, DecideTransportRetryExhaustedError))
         return { kind: 'unsettled', ...base, cause: 'transport_exhausted', refusal, ...detail };
     return { kind: 'unsettled', ...base, cause: unsettledCauseOfReading(refusal), refusal, ...detail };
 }
+export function directSafetyStopOf(e) {
+    if (!isSlotCarrier(e) || !safetyStopNamed(e))
+        return undefined;
+    const triaged = transportReadingOf(e, undefined);
+    return Object.freeze({ thrown: e, head: safetyStopHeadOf(e, localCodeReadOf(triaged, e), true), triaged });
+}
+export function directFailureVerdictOf(e, stop) {
+    const settled = directFailureReadingOf(e, stop !== undefined ? stop.triaged : transportReadingOf(e, undefined), stop !== undefined ? stop.head : { named: false });
+    const yields = isLocalSafetyStop(carrierReadOf(settled.thrown, settled.reading), settled.reading);
+    return Object.freeze({ yields, ...(stop !== undefined ? { directStop: Object.freeze({ ...stop, settled }) } : {}) });
+}
+function bothAbsent(cause, status) {
+    return cause === 'absent' && status === 'absent';
+}
+function zeroByteProven(e, reading, viaDelivery, afterRetry) {
+    if (afterRetry)
+        return false;
+    if (reading === undefined)
+        return false;
+    if (viaDelivery && ownReadingSlot(reading, 'cls') === 'transport')
+        return false;
+    const u = ownReadingSlot(reading, 'unanswered');
+    return u !== undefined && u.layer === e && isSlotCarrier(e) && bothAbsent(ownReadingSlot(topCauseReadOf(reading, e), 'presence'), ownReadingSlot(u, 'statusSlot'));
+}
 export function joinedResolution(r, gatedCallId) {
     const carry = r.gatedCallId === undefined && gatedCallId !== undefined && gatedCallId !== '' ? { gatedCallId } : {};
     return { ...r, ...carry, joinedInFlight: true };

package/dist/hitl/askClassPair.d.ts

@@ -1,5 +1,5 @@
-import { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
-export declare const DEPLOYMENT_LIST_ASK_CLASSES: readonly (keyof typeof CORE_MODE_ARBITRATION)[];
+import { CORE_ASK_CLASSES } from '../generated/engineFactTables.js';
+export declare const DEPLOYMENT_LIST_ASK_CLASSES: readonly (typeof CORE_ASK_CLASSES)[number][];
 export type AskClassPairReading = {
     readonly state: 'pair';
     readonly askClass: string;
@@ -14,3 +14,9 @@ export declare function readAskClassPair(v: object | null | undefined): {
     askClass: string;
     classes: readonly string[];
 } | undefined;
+export interface AskClassReasonRow {
+    readonly askClass: string;
+    readonly reason: string;
+}
+export declare function askClassReasonOf(askClass: string | null | undefined): string | undefined;
+export declare function askClassReasonsOf(carrier: object | null | undefined): readonly AskClassReasonRow[];

package/dist/hitl/askClassPair.js

@@ -1,4 +1,5 @@
-import { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
+import { appendOwnElement } from '../ownKey.js';
+import { CORE_ASK_CLASSES, CORE_ASK_CLASS_REASONS } from '../generated/engineFactTables.js';
 export const DEPLOYMENT_LIST_ASK_CLASSES = Object.freeze(['ask_rule']);
 const ABSENT = Object.freeze({ state: 'absent' });
 const MALFORMED = Object.freeze({ state: 'malformed' });
@@ -24,13 +25,13 @@ export function readAskClassPairState(v) {
     const seen = new Set();
     for (let i = 0; i < length; i++) {
         const d = Object.getOwnPropertyDescriptor(raw, i);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             return MALFORMED;
         const c = d.value;
         if (typeof c !== 'string' || c === '' || seen.has(c))
             return MALFORMED;
         seen.add(c);
-        classes.push(c);
+        appendOwnElement(classes, c);
     }
     if (raw.length !== length)
         return MALFORMED;
@@ -41,7 +42,7 @@ export function readAskClassPairState(v) {
     return Object.freeze({ state: 'pair', askClass, classes: Object.freeze(classes) });
 }
 function inCanonicalOrder(classes) {
-    const order = Object.keys(CORE_MODE_ARBITRATION);
+    const order = CORE_ASK_CLASSES;
     let last = -1;
     for (const c of classes) {
         const rank = order.indexOf(c);
@@ -57,3 +58,29 @@ export function readAskClassPair(v) {
     const r = readAskClassPairState(v);
     return r.state === 'pair' ? { askClass: r.askClass, classes: r.classes } : undefined;
 }
+export function askClassReasonOf(askClass) {
+    if (typeof askClass !== 'string' || askClass === '')
+        return undefined;
+    return Object.hasOwn(CORE_ASK_CLASS_REASONS, askClass) ? CORE_ASK_CLASS_REASONS[askClass] : undefined;
+}
+export function askClassReasonsOf(carrier) {
+    let pair;
+    try {
+        pair = readAskClassPairState(carrier);
+    }
+    catch {
+        return Object.freeze([]);
+    }
+    if (pair.state !== 'pair')
+        return Object.freeze([]);
+    const seen = new Set();
+    const rows = [];
+    for (const askClass of pair.classes) {
+        const reason = askClassReasonOf(askClass);
+        if (reason === undefined || seen.has(reason))
+            continue;
+        seen.add(reason);
+        rows.push(Object.freeze({ askClass, reason }));
+    }
+    return Object.freeze(rows);
+}

package/dist/hitl/askParkAutoReopenBlock.d.ts

@@ -0,0 +1,30 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
+export declare const ASK_PARK_AUTO_REOPEN_BLOCKS: readonly ["policy", "park_refused"];
+export type AskParkAutoReopenBlock = (typeof ASK_PARK_AUTO_REOPEN_BLOCKS)[number];
+export declare function askParkRefusalBlockOf(err: {} | null | undefined): AskParkAutoReopenBlock | undefined;
+export declare function askParkBlockGeneration(sessionId?: string): string;
+export interface AskParkDecideIdentity {
+    readonly taskId: string;
+    readonly sessionId: string;
+    readonly boundCallId?: string;
+}
+export declare function noteAskParkDecideSettled(identity: AskParkDecideIdentity, startedGeneration: string, outcome: {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: {} | null | undefined;
+}): void;
+export interface AskParkGate {
+    readonly callId: string;
+    readonly sessionId?: string;
+}
+export declare function askParkAutoReopenBlockOf(gate: AskParkGate): AskParkAutoReopenBlock | undefined;
+export interface AskParkAutoReopenBlockNotice {
+    readonly kind: AskParkAutoReopenBlock;
+    readonly text: string;
+    delivered(): void;
+}
+export declare function claimAskParkAutoReopenBlockNotice(gate: AskParkGate, lane?: 'interactive' | 'print', lang?: UiLanguage): AskParkAutoReopenBlockNotice | undefined;
+export declare function askParkAutoReopenBlockedContent(kind: AskParkAutoReopenBlock, taskId: string, lane?: 'interactive' | 'print', lang?: UiLanguage): string;
+export declare function clearAskParkAutoReopenBlocks(sessionId?: string): void;
+export declare function __resetAskParkAutoReopenBlocksForTests(): void;

package/dist/hitl/askParkAutoReopenBlock.js

@@ -0,0 +1,117 @@
+import { hostLog } from '../host.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { refusedParkBlockedContent, refusedParkFromError, resumePolicyBlockFromError } from '../resumeRefusalCopy.js';
+export const ASK_PARK_AUTO_REOPEN_BLOCKS = Object.freeze(['policy', 'park_refused']);
+export function askParkRefusalBlockOf(err) {
+    try {
+        if (resumePolicyBlockFromError(err) !== null)
+            return 'policy';
+        if (refusedParkFromError(err) !== null)
+            return 'park_refused';
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const blocks = new Map();
+const BLOCK_MAX = 64;
+let generation = 0;
+const sessionGenerations = new Map();
+export function askParkBlockGeneration(sessionId) {
+    return `${generation}:${typeof sessionId === 'string' ? (sessionGenerations.get(sessionId) ?? 0) : 0}`;
+}
+export function noteAskParkDecideSettled(identity, startedGeneration, outcome) {
+    try {
+        if (startedGeneration !== askParkBlockGeneration(identity.sessionId))
+            return;
+        const callId = identity.boundCallId;
+        if (typeof callId !== 'string' || callId === '')
+            return;
+        if (outcome.ok) {
+            blocks.delete(callId);
+            return;
+        }
+        const kind = askParkRefusalBlockOf(outcome.error);
+        if (kind === undefined)
+            return;
+        const prev = blocks.get(callId);
+        blocks.delete(callId);
+        if (prev !== undefined && prev.kind === kind && prev.sessionId === identity.sessionId)
+            blocks.set(callId, prev);
+        else
+            blocks.set(callId, { kind, sessionId: identity.sessionId, taskId: identity.taskId, announced: false });
+        while (blocks.size > BLOCK_MAX) {
+            const oldest = blocks.keys().next();
+            if (oldest.done === true)
+                break;
+            blocks.delete(oldest.value);
+        }
+    }
+    catch (e) {
+        hostLog('debug', `askParkAutoReopenBlock.noteSettled: ${String(e).slice(0, 120)}`);
+    }
+}
+function entryFor(gate) {
+    if (typeof gate !== 'object' || gate === null || typeof gate.callId !== 'string' || gate.callId === '')
+        return undefined;
+    const e = blocks.get(gate.callId);
+    if (e === undefined)
+        return undefined;
+    if (typeof gate.sessionId === 'string' && gate.sessionId !== '' && e.sessionId !== undefined && e.sessionId !== gate.sessionId)
+        return undefined;
+    return e;
+}
+export function askParkAutoReopenBlockOf(gate) {
+    try {
+        return entryFor(gate)?.kind;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function claimAskParkAutoReopenBlockNotice(gate, lane = 'interactive', lang) {
+    try {
+        const e = entryFor(gate);
+        if (e === undefined || e.announced)
+            return undefined;
+        const text = askParkAutoReopenBlockedContent(e.kind, e.taskId, lane, lang);
+        return Object.freeze({
+            kind: e.kind,
+            text,
+            delivered: () => {
+                const cur = entryFor(gate);
+                if (cur === e)
+                    e.announced = true;
+            },
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function askParkAutoReopenBlockedContent(kind, taskId, lane = 'interactive', lang) {
+    if (kind === 'park_refused')
+        return refusedParkBlockedContent(taskId, lane, lang);
+    const run = typeof taskId === 'string' && taskId !== '' ? taskId : '<unknown>';
+    if (lane === 'print')
+        return renderMessage(msg('approval.askPark.autoReopenBlocked.policyPrint', { run, cancel: `POST /v1/runs/${run}/cancel` }), lang);
+    return renderMessage(msg('approval.askPark.autoReopenBlocked.policyInteractive', { run }), lang);
+}
+export function clearAskParkAutoReopenBlocks(sessionId) {
+    if (typeof sessionId !== 'string' || sessionId === '') {
+        generation++;
+        sessionGenerations.clear();
+        blocks.clear();
+        return;
+    }
+    sessionGenerations.set(sessionId, (sessionGenerations.get(sessionId) ?? 0) + 1);
+    for (const [k, e] of blocks)
+        if (e.sessionId === sessionId)
+            blocks.delete(k);
+}
+export function __resetAskParkAutoReopenBlocksForTests() {
+    blocks.clear();
+    sessionGenerations.clear();
+    generation = 0;
+}

package/dist/hitl/askParkRowRouting.js

@@ -1,5 +1,5 @@
 import { askParkForeignGateKind, durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
-import { isAskTool } from './frameRouter.js';
+import { isAskTool, questionCardVerdict } from './frameRouter.js';
 import { approvalCallKey } from './gateIdentity.js';
 import { askQuestionsFromPending, pendingRowIsOwnedByThisSession } from './parkOwnership.js';
 export const ASK_PARK_ROW_WAIT_MS = 15000;
@@ -39,6 +39,9 @@ export function askParkRowIdentity(taskId, row) {
     return { rowTaskId, gatedCallId, armedKey: approvalCallKey(gatedCallId, rowTaskId) };
 }
 export function askParkRowArm(row) {
+    const byCard = questionCardVerdict(row);
+    if (byCard !== undefined)
+        return byCard ? 'question' : 'tool-gate';
     const rowGateKind = askParkRowGateKind(row);
     const toolNameIsAsk = isAskTool(row.toolName ?? undefined);
     if (toolNameIsAsk)

package/dist/hitl/attributionLadder.d.ts

@@ -0,0 +1,62 @@
+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;
+    decidedBy?: unknown;
+}>(body: T): Omit<T, 'settledBy' | 'decidedBy'>;
+export declare function withAttributionKeyRenamed<T extends {
+    settledBy?: unknown;
+    decidedBy?: unknown;
+}>(body: T): Omit<T, 'settledBy' | 'decidedBy'> & {
+    decidedBy?: Exclude<T['settledBy'], undefined>;
+};
+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) | undefined, source: LadderReadingSource): Promise<R>;

package/dist/hitl/attributionLadder.js

@@ -0,0 +1,138 @@
+import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
+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 refusal?.kind === 'not_in_proof';
+}
+export function shouldResendUnderSuccessorKey(refusal, lastSendCarriedRetiredKey, signal) {
+    if (!lastSendCarriedRetiredKey)
+        return false;
+    if (signal?.aborted === true)
+        return false;
+    return refusal?.kind === 'retired_key';
+}
+export function carriesAttributionKey(body) {
+    return Object.hasOwn(body, 'settledBy') || Object.hasOwn(body, 'decidedBy');
+}
+export function withoutAttributionKey(body) {
+    const { settledBy: _droppedSettledBy, decidedBy: _droppedDecidedBy, ...rest } = body;
+    void _droppedSettledBy;
+    void _droppedDecidedBy;
+    return rest;
+}
+export function withAttributionKeyRenamed(body) {
+    const { settledBy, decidedBy: _replaced, ...rest } = body;
+    void _replaced;
+    return settledBy === undefined ? rest : { ...rest, decidedBy: settledBy };
+}
+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) {
+        const firstRefusal = ladderRefusalOf(first, source, state);
+        if (shouldResendWithoutAttribution(firstRefusal, state.lastCarried, signal)) {
+            const withoutAttribution = withoutAttributionKey(body);
+            state.lastCarried = false;
+            onStep?.('dropped');
+            const r = await send(withoutAttribution);
+            state.dropped = true;
+            return r;
+        }
+        if (shouldResendUnderSuccessorKey(firstRefusal, Object.hasOwn(body, 'settledBy'), signal)) {
+            const renamed = withAttributionKeyRenamed(body);
+            onStep?.('renamed');
+            try {
+                const r = await send(renamed);
+                state.renamed = true;
+                return r;
+            }
+            catch (second) {
+                if (!shouldResendWithoutAttribution(ladderRefusalOf(second, source, state), true, signal))
+                    throw second;
+                const renamedWithoutAttribution = withoutAttributionKey(renamed);
+                state.lastCarried = false;
+                onStep?.('renamed_then_dropped');
+                const r = await send(renamedWithoutAttribution);
+                state.dropped = true;
+                return r;
+            }
+        }
+        throw first;
+    }
+}

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;