@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/hitl/approvalDelivery.d.ts

@@ -0,0 +1,87 @@
+import { type AnswerCapture, type TopCauseReading, type TopLocalCodeReading, type UnansweredCapture } from '../engineWireFor.js';
+import { type AttributionLadderState, type AttributionLadderStep } from './attributionLadder.js';
+import { type RefusalCarrier, type SafetyStopHead } from './hitlBridge.js';
+export declare const PARKING_WAIT_CAP_MS = 5000;
+export interface DeliveryTiming {
+    readonly delays?: readonly number[];
+    readonly budgetMs?: number;
+    readonly parkingDelayMs?: number;
+}
+export declare function setDeliveryTimingForTests(t?: DeliveryTiming): void;
+export interface DeliveryTimingReading {
+    readonly delays: readonly number[];
+    readonly budgetMs: number;
+    readonly parkingDelayMs: number | undefined;
+}
+export declare function deliveryTiming(): DeliveryTimingReading;
+export type TransportClass = 'aborted' | 'transport' | 'server_5xx' | 'verdict' | 'local_error';
+export interface TransportReading {
+    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 transportReadingOf(e: {} | null | undefined, signal: AbortSignal | undefined): TransportReading;
+export declare function settledTransportReadingOf(e: {} | null | undefined, signal: AbortSignal | undefined, tally: SendTally): TransportReading;
+export declare function deliveryReadingOf(thrown: {} | null | undefined, tally: SendTally): TransportReading | undefined;
+export declare function transportClassOf(e: {} | null | undefined, signal: AbortSignal | undefined): TransportClass;
+export interface SendTally {
+    attempts: number;
+    retried: boolean;
+    readonly startedAt: number;
+    lastThrown: {
+        readonly thrown: {} | null | undefined;
+        readonly reading: TransportReading;
+    } | undefined;
+}
+export declare function newSendTally(): SendTally;
+export declare function budgetSpent(tally: SendTally, extraMs: number): boolean;
+export declare function isAborted(signal: AbortSignal | undefined): boolean;
+export declare function sleepFor(ms: number, signal: AbortSignal | undefined): Promise<void>;
+export declare function withTransportRetry<T>(send: (signal: AbortSignal | undefined) => Promise<T>, signal: AbortSignal | undefined, tally: SendTally, deadlineOnFirst?: boolean): Promise<T>;
+export interface SettledFailureReading {
+    readonly thrown: {} | null | undefined;
+    readonly reading: TransportReading;
+}
+export declare function directFailureReadingOf(e: {} | null | undefined, triaged: TransportReading, topHead: SafetyStopHead): SettledFailureReading;
+export interface ApprovalParkingFacts {
+    readonly approvalId: string;
+    readonly retryAfterMs?: number;
+}
+export declare function approvalParkingRetryWait(view: ApprovalParkingFacts, tally: SendTally, signal: AbortSignal | undefined): number | undefined;
+export type ApprovalDelivery = {
+    readonly kind: 'answered';
+    readonly raw: {} | null | undefined;
+    readonly parkingRetried?: true;
+} | {
+    readonly kind: 'thrown';
+    readonly error: {} | null | undefined;
+    readonly reading: TransportReading;
+    readonly transportExhausted: boolean;
+    readonly afterRetry: boolean;
+    readonly parkingRetried?: true;
+};
+export interface ApprovalDeliveryInput<B extends {
+    settledBy?: unknown;
+    decidedBy?: unknown;
+}> {
+    readonly approvalId: string;
+    readonly body: B;
+    readonly send: (body: B, signal: AbortSignal | undefined) => Promise<{} | null | undefined | void>;
+    readonly signal: AbortSignal | undefined;
+    readonly tally: SendTally;
+    readonly ladder: AttributionLadderState;
+    readonly onLadderStep?: (step: AttributionLadderStep) => void;
+    readonly parkingOf: (raw: {} | null | undefined) => ApprovalParkingFacts | undefined;
+}
+export declare function deliverApprovalDecision<B extends {
+    settledBy?: unknown;
+    decidedBy?: unknown;
+}>(input: ApprovalDeliveryInput<B>): Promise<ApprovalDelivery>;

package/dist/hitl/approvalDelivery.js

@@ -0,0 +1,193 @@
+import { abortableSleep } from '../abortableSleep.js';
+import { classifyTurnWireError } from '../wireErrorTriage.js';
+import { ownReadingSlot, triageReadingOf } from '../engineWireFor.js';
+import { isSlotCarrier, readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
+import { deliverWithAttributionLadder, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
+import { GATE_FAILURE_CODES, refusalCarrierOf, safetyStopHeadOf } from './hitlBridge.js';
+const RETRY_DELAYS_MS = Object.freeze([500, 1_000, 2_000]);
+const RETRY_BUDGET_MS = 8_000;
+export const PARKING_WAIT_CAP_MS = 5_000;
+let timingOverride;
+export function setDeliveryTimingForTests(t) {
+    timingOverride = t;
+}
+export function deliveryTiming() {
+    return { delays: timingOverride?.delays ?? RETRY_DELAYS_MS, budgetMs: timingOverride?.budgetMs ?? RETRY_BUDGET_MS, parkingDelayMs: timingOverride?.parkingDelayMs };
+}
+function isAbortShaped(e) {
+    const name = readThrownSlot(e, 'name');
+    return name === 'TimeoutError' || name === 'AbortError';
+}
+export function transportReadingOf(e, signal) {
+    const reading = triageReadingOf(classifyTurnWireError(e));
+    const answered = ownReadingSlot(reading, 'answer');
+    const unanswered = ownReadingSlot(reading, 'unanswered');
+    const topLocalCode = ownReadingSlot(reading, 'topLocalCode');
+    const topCause = ownReadingSlot(reading, 'topCause');
+    const topFacts = { ...(topLocalCode !== undefined ? { topLocalCode } : {}), ...(topCause !== undefined ? { topCause } : {}) };
+    const layer = answered !== undefined && answered !== THROWN_SLOT_UNREADABLE ? { answered, ...topFacts } : unanswered !== undefined ? { unanswered, ...topFacts } : topFacts;
+    if (signal?.aborted === true)
+        return { cls: 'aborted', ...layer };
+    if (reading === undefined || answered === THROWN_SLOT_UNREADABLE)
+        return { cls: 'local_error', ...topFacts };
+    if (answered !== undefined)
+        return { cls: answered.status === 501 ? 'verdict' : answered.status >= 500 ? 'server_5xx' : 'verdict', ...layer };
+    return { cls: reading.transport || isAbortShaped(e) ? 'transport' : 'local_error', ...layer };
+}
+export function settledTransportReadingOf(e, signal, tally) {
+    const last = ownReadingSlot(tally, 'lastThrown');
+    if (last === undefined || last.thrown !== e)
+        return transportReadingOf(e, signal);
+    if (signal?.aborted === true)
+        return { ...last.reading, cls: 'aborted' };
+    return last.reading;
+}
+export function deliveryReadingOf(thrown, tally) {
+    const last = ownReadingSlot(tally, 'lastThrown');
+    return last !== undefined && last.thrown === thrown ? last.reading : undefined;
+}
+export function transportClassOf(e, signal) {
+    return transportReadingOf(e, signal).cls;
+}
+export function newSendTally() {
+    return { attempts: 0, retried: false, startedAt: Date.now(), lastThrown: undefined };
+}
+function attemptSignal(withDeadline, caller, startedAt, budgetMs) {
+    if (!withDeadline)
+        return caller;
+    const deadline = AbortSignal.timeout(Math.max(1, budgetMs - (Date.now() - startedAt)));
+    if (caller === undefined)
+        return deadline;
+    if (typeof AbortSignal.any === 'function')
+        return AbortSignal.any([caller, deadline]);
+    const ac = new AbortController();
+    const abort = (s) => ac.abort(s.reason);
+    if (caller.aborted)
+        abort(caller);
+    else
+        caller.addEventListener('abort', () => abort(caller), { once: true });
+    deadline.addEventListener('abort', () => abort(deadline), { once: true });
+    return ac.signal;
+}
+export function budgetSpent(tally, extraMs) {
+    return Date.now() - tally.startedAt + extraMs >= deliveryTiming().budgetMs;
+}
+export function isAborted(signal) {
+    return signal?.aborted === true;
+}
+export function sleepFor(ms, signal) {
+    return abortableSleep(ms, signal ?? new AbortController().signal);
+}
+export async function withTransportRetry(send, signal, tally, deadlineOnFirst = false) {
+    const { delays, budgetMs } = deliveryTiming();
+    const startedAt = tally.startedAt;
+    for (let attempt = 1;; attempt++) {
+        tally.attempts++;
+        try {
+            return await send(attemptSignal(attempt > 1 || deadlineOnFirst, signal, startedAt, budgetMs));
+        }
+        catch (e) {
+            const reading = transportReadingOf(e, signal);
+            const cls = reading.cls;
+            const delay = delays[attempt - 1] ?? 0;
+            const heads = localStopHeadsOf(e, reading);
+            const retriable = (cls === 'transport' || cls === 'server_5xx') && heads.safetyStop !== true;
+            const overBudget = Date.now() - startedAt + delay >= budgetMs;
+            if (!retriable || attempt > delays.length || overBudget)
+                throw answeredError(settledReadingOf(e, reading, heads), tally);
+            tally.retried = true;
+            await sleepFor(delay, signal);
+            if (signal?.aborted === true || Date.now() - startedAt >= budgetMs)
+                throw answeredError(settledReadingOf(e, reading, heads), tally);
+        }
+    }
+}
+function answeredError(settled, tally) {
+    tally.lastThrown = settled;
+    return settled.thrown;
+}
+function isLocalClosedCode(v) {
+    return typeof v === 'string' && GATE_FAILURE_CODES.includes(v);
+}
+function localStopHeadsOf(top, reading, known) {
+    const answered = ownReadingSlot(reading, 'answered')?.layer;
+    const deep = answered !== undefined && answered !== top ? answered : undefined;
+    const topCode = isSlotCarrier(top) ? localCodeReadOf(reading, top) : undefined;
+    const topHead = known ?? (!isSlotCarrier(top) ? undefined : topCode === undefined ? safetyStopHeadOf(top) : isLocalClosedCode(topCode.value) ? safetyStopHeadOf(top, topCode) : undefined);
+    const deepCode = deep !== undefined ? localCodeReadOf(reading, deep) : undefined;
+    const layerHead = deep !== undefined && deepCode !== undefined && isLocalClosedCode(deepCode.value) ? safetyStopHeadOf(deep, deepCode) : undefined;
+    const safetyStop = topHead?.local !== undefined || layerHead?.local !== undefined;
+    return Object.freeze({ ...(safetyStop ? { safetyStop: true } : {}), ...(topHead !== undefined ? { top: topHead } : {}), ...(layerHead !== undefined ? { layer: layerHead } : {}) });
+}
+function settledReadingOf(e, reading, heads) {
+    const top = e;
+    const layer = ownReadingSlot(reading, 'answered')?.layer;
+    const wrapper = isSlotCarrier(top) ? refusalCarrierOf(top, localCodeReadOf(reading, top), false, topCauseReadOf(reading, top), heads.top) : undefined;
+    const thrown = layer === undefined ? top : layer;
+    const reads = [];
+    if (wrapper !== undefined && isSlotCarrier(top))
+        reads.push(Object.freeze({ thrown: top, read: wrapper }));
+    if (layer !== undefined && layer !== top)
+        reads.push(Object.freeze({ thrown: layer, read: refusalCarrierOf(layer, localCodeReadOf(reading, layer), true, undefined, heads.layer) }));
+    const bindingMismatchWrapper = layer !== undefined && layer !== top && wrapper !== undefined && ownReadingSlot(wrapper, 'local') === 'binding_mismatch';
+    const safetyStop = heads.safetyStop === true;
+    const settled = reads.length > 0 || bindingMismatchWrapper || safetyStop
+        ? { ...reading, ...(reads.length > 0 ? { carrierReads: Object.freeze(reads) } : {}), ...(bindingMismatchWrapper ? { bindingMismatchWrapper: true } : {}), ...(safetyStop ? { safetyStop: true } : {}) }
+        : reading;
+    return { thrown, reading: settled };
+}
+export function directFailureReadingOf(e, triaged, topHead) {
+    return settledReadingOf(e, triaged, localStopHeadsOf(e, triaged, topHead));
+}
+export function approvalParkingRetryWait(view, tally, signal) {
+    const w = ownReadingSlot(view, 'retryAfterMs');
+    if (typeof w !== 'number' || !Number.isFinite(w) || w < 0)
+        return undefined;
+    if (w > PARKING_WAIT_CAP_MS)
+        return undefined;
+    if (isAborted(signal) || budgetSpent(tally, w))
+        return undefined;
+    return w;
+}
+function thrownFacts(e, signal, tally) {
+    const reading = settledTransportReadingOf(e, signal, tally);
+    return { reading, transportExhausted: reading.cls === 'transport' && tally.retried, afterRetry: tally.retried };
+}
+export async function deliverApprovalDecision(input) {
+    const { signal, tally } = input;
+    let last = input.body;
+    let raw;
+    try {
+        raw = (await deliverWithAttributionLadder(input.body, (b) => {
+            last = b;
+            return withTransportRetry((sig) => input.send(b, sig), signal, tally);
+        }, signal, input.ladder, input.onLadderStep, { kind: 'delivered', readingOf: (thrown) => deliveryReadingOf(thrown, tally) }));
+    }
+    catch (e) {
+        return { kind: 'thrown', error: e, ...thrownFacts(e, signal, tally) };
+    }
+    let parking;
+    try {
+        parking = input.parkingOf(raw);
+    }
+    catch {
+        parking = undefined;
+    }
+    if (parking === undefined || parking.approvalId !== input.approvalId)
+        return { kind: 'answered', raw };
+    const wait = approvalParkingRetryWait(parking, tally, signal);
+    if (wait === undefined)
+        return { kind: 'answered', raw };
+    await sleepFor(wait, signal);
+    if (isAborted(signal) || budgetSpent(tally, 0))
+        return { kind: 'answered', raw };
+    tally.retried = false;
+    const resent = last;
+    try {
+        const raw2 = (await withTransportRetry((sig) => input.send(resent, sig), signal, tally, true));
+        return { kind: 'answered', raw: raw2, parkingRetried: true };
+    }
+    catch (e) {
+        return { kind: 'thrown', error: e, ...thrownFacts(e, signal, tally), parkingRetried: true };
+    }
+}

package/dist/hitl/approvalResolution.d.ts

@@ -3,6 +3,7 @@ import { type HitlSafetyCode } from './hitlBridge.js';
 import type { AskAnsweredOutput } from './gateLedger.js';
 import type { ApprovalDenySettledBy, ToolApprovalRespondAckView, ToolApprovalRespondDecision, ToolApprovalRespondParkingView } from './toolApprovalWire.js';
 import { type DecisionRefusalReading, type RefusalRouteContext } from './decisionRefusal.js';
+import { type DeliveredReading, type LadderSafetyStop } from './attributionLadder.js';
 export declare const APPROVAL_RESOLUTION_LANES: readonly ["respond", "decide", "ask"];
 export type ApprovalResolutionLane = (typeof APPROVAL_RESOLUTION_LANES)[number];
 export declare const APPROVAL_NOT_SENT_CAUSES: readonly ["retracted", "edit_refused", "no_pending", "wrong_gate", "fetch_failed", "no_input", "card_unavailable", "safety_stop"];
@@ -55,7 +56,17 @@ export interface DecisionFailureMint {
     readonly gatedCallId?: string | undefined;
     readonly detail?: string | undefined;
     readonly attributionCarried?: boolean | undefined;
+    readonly transportExhausted?: boolean | undefined;
+    readonly afterRetry?: boolean | undefined;
+    readonly delivered?: DeliveredReading | undefined;
+    readonly directStop?: LadderSafetyStop | undefined;
 }
 export declare function resolutionOfDecisionFailure(e: {} | null | undefined, m: DecisionFailureMint): ApprovalResolution;
+export declare function directSafetyStopOf(e: {} | null | undefined): LadderSafetyStop | undefined;
+export interface DirectFailureVerdict {
+    readonly yields: boolean;
+    readonly directStop?: LadderSafetyStop;
+}
+export declare function directFailureVerdictOf(e: {} | null | undefined, stop: LadderSafetyStop | undefined): DirectFailureVerdict;
 export declare function joinedResolution(r: ApprovalResolution, gatedCallId?: string): ApprovalResolution;
 export {};

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

@@ -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_ASK_CLASSES } 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;
@@ -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)