@sema-agent/client-core 0.97.1 → 0.98.0

package/dist/hitl/approvalHolds.js

@@ -1,51 +1,149 @@
 import { hostLog } from '../host.js';
 import { liveFrameCallKey } from './gateIdentity.js';
-import { approvalResolutionOf } from './approvalResolution.js';
+import { decideReceiptReopen } from '../decideReceipt.js';
 export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
 export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
-export function liveCardHoldFor(who) {
-    if (nonEmpty(who.approvalId))
-        return liveCardHoldOf(liveFrameCallKey(who.approvalId));
-    if (!nonEmpty(who.taskId) || !nonEmpty(who.toolCallId))
-        return undefined;
+function sameApproval(who, h) {
+    const id = h.identity;
+    if (nonEmpty(who.approvalId) && nonEmpty(id.approvalId))
+        return who.approvalId === id.approvalId;
+    if (h.phase !== 'card')
+        return false;
+    if (!nonEmpty(who.taskId) || !nonEmpty(who.toolCallId) || id.taskId !== who.taskId || id.toolCallId !== who.toolCallId)
+        return false;
+    if (nonEmpty(who.sessionId) && nonEmpty(id.sessionId) && id.sessionId !== who.sessionId)
+        return false;
+    return !(nonEmpty(who.askSig) && nonEmpty(id.askSig) && id.askSig !== who.askSig);
+}
+export function approvalHoldFor(who, except) {
     for (const h of approvalDecisionHolds.inFlight.values()) {
-        if (h.lane !== 'live' || h.phase !== 'card')
+        if (except?.(h) === true)
             continue;
-        const id = h.identity;
-        if (id.taskId !== who.taskId || id.toolCallId !== who.toolCallId)
-            continue;
-        if (nonEmpty(who.sessionId) && nonEmpty(id.sessionId) && id.sessionId !== who.sessionId)
-            continue;
-        return h;
+        if (sameApproval(who, h))
+            return h;
     }
     return undefined;
 }
 export function settledForDurableLane(entry) {
     return entry !== undefined && !entry.parked;
 }
-export function liveCardAnsweredHow(o) {
-    return answeredHowOf(approvalResolutionOf(o));
-}
-function answeredHowOf(r) {
+export function liveCardAnsweredHow(r) {
     if (r.kind === 'decided')
         return 'answered';
     return r.kind === 'unsettled' && r.cause === 'interrupted' ? 'interrupted' : undefined;
 }
-export async function awaitLiveCardHolder(hold, signal) {
+const HOLDER_FREE = Object.freeze({ kind: 'free' });
+function nothingSentHere(asker) {
+    return Object.freeze({ kind: 'not_sent', lane: asker, cause: 'retracted' });
+}
+function interruptedThere(asker) {
+    return Object.freeze({ kind: 'unsettled', lane: asker, cause: 'interrupted' });
+}
+export async function awaitApprovalHolder(hold, signal, asker) {
+    if (hold.lane === 'host')
+        return awaitHostHolder(hold, signal, asker);
     const unsubscribe = followCallerSignal(signal, hold.interrupt);
-    let o;
     try {
-        o = await hold.outcome;
+        if (hold.lane === 'live') {
+            let o;
+            try {
+                o = await hold.outcome;
+            }
+            catch {
+                return HOLDER_FREE;
+            }
+            const stillHeld = approvalDecisionHolds.inFlight.get(liveFrameCallKey(hold.identity.approvalId)) === hold;
+            const entry = settledApprovalOf(hold.identity.approvalId);
+            if (!stillHeld && !settledForDurableLane(entry))
+                return HOLDER_FREE;
+            return Object.freeze({ kind: 'settled', how: entry?.how === 'answered' ? 'answered' : 'interrupted', outcome: o });
+        }
+        let r;
+        try {
+            r = await hold.outcome;
+        }
+        catch {
+            return HOLDER_FREE;
+        }
+        if (r.kind === 'decided') {
+            if (decideReceiptReopen(r.receipt) !== null)
+                return HOLDER_FREE;
+            return Object.freeze({ kind: 'settled', how: 'answered', outcome: r });
+        }
+        if (r.kind !== 'unsettled' || r.cause !== 'interrupted' || hold.trailing === undefined)
+            return HOLDER_FREE;
+        const landed = await hold.trailing.then(() => true, () => false);
+        return landed ? Object.freeze({ kind: 'settled', how: 'interrupted', outcome: r }) : HOLDER_FREE;
     }
-    catch {
-        return undefined;
+    finally {
+        unsubscribe();
+    }
+}
+async function awaitHostHolder(hold, signal, asker) {
+    let leave = () => { };
+    const left = new Promise((resolve) => {
+        leave = () => resolve('left');
+    });
+    const unsubscribe = followCallerSignal(signal, leave);
+    try {
+        const r = await Promise.race([hold.released, left]);
+        if (r === 'left')
+            return Object.freeze({ kind: 'left' });
+        if (r === undefined)
+            return HOLDER_FREE;
+        return Object.freeze({ kind: 'settled', how: r, outcome: r === 'interrupted' ? interruptedThere(asker) : nothingSentHere(asker) });
     }
     finally {
         unsubscribe();
     }
-    const stillHeld = approvalDecisionHolds.inFlight.get(liveFrameCallKey(hold.identity.approvalId)) === hold;
-    return stillHeld || settledForDurableLane(settledApprovalOf(hold.identity.approvalId)) ? { ...o, joinedInFlight: true } : undefined;
+}
+function holdHostCard(identity) {
+    const h = approvalDecisionHolds;
+    const key = `hitl-host:${++h.clock}`;
+    let resolveReleased = () => { };
+    const released = new Promise((resolve) => {
+        resolveReleased = resolve;
+    });
+    const frozen = Object.freeze({ ...identity });
+    const hold = { lane: 'host', identity: frozen, phase: 'card', released };
+    h.inFlight.set(key, hold);
+    let done = false;
+    return Object.freeze({
+        identity: frozen,
+        sending: () => {
+            if (!done)
+                hold.phase = 'respond';
+        },
+        release: (settled) => {
+            if (done)
+                return;
+            done = true;
+            const how = settled === 'answered' || settled === 'interrupted' ? settled : undefined;
+            if (how !== undefined && nonEmpty(frozen.approvalId))
+                noteSettled(frozen.approvalId, how, false, how === 'interrupted' ? interruptedThere('decide') : nothingSentHere('decide'), true);
+            if (h.inFlight.get(key) === hold)
+                h.inFlight.delete(key);
+            resolveReleased(how);
+        },
+    });
+}
+const CLAIM_MAX_ROUNDS = 8;
+export async function claimApprovalCardFor(who, signal) {
+    for (let round = 0; round < CLAIM_MAX_ROUNDS; round++) {
+        const entry = settledApprovalOf(who.approvalId);
+        if (settledForDurableLane(entry) && entry !== undefined)
+            return Object.freeze({ kind: 'joined', outcome: { ...entry.outcome, joinedInFlight: true } });
+        const holder = approvalHoldFor(who);
+        if (holder === undefined)
+            return Object.freeze({ kind: 'held', hold: holdHostCard(who) });
+        const wait = await awaitApprovalHolder(holder, signal, 'decide');
+        if (wait.kind === 'settled')
+            return Object.freeze({ kind: 'joined', outcome: { ...wait.outcome, joinedInFlight: true } });
+        if (wait.kind === 'left')
+            return Object.freeze({ kind: 'joined', outcome: { ...nothingSentHere('decide'), joinedInFlight: true } });
+    }
+    return Object.freeze({ kind: 'held', hold: holdHostCard(who) });
 }
 export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), outcomes: new Map(), clock: 0 };
 export function settledApprovalOf(approvalId) {
@@ -57,14 +155,17 @@ export function clearSettledApprovals() {
 export function anyApprovalSettled() {
     return approvalDecisionHolds.outcomes.size > 0;
 }
-function noteSettled(approvalId, how, parked, outcome) {
+function noteSettled(approvalId, how, parked, outcome, upgradesParked = false) {
     if (typeof approvalId !== 'string' || approvalId === '')
         return;
     if (!APPROVAL_SETTLED_HOWS.includes(how))
         return;
     const t = approvalDecisionHolds.outcomes;
-    if (t.has(approvalId))
+    const prev = t.get(approvalId);
+    if (prev !== undefined && !(upgradesParked && prev.parked && how !== 'closed_by_engine'))
         return;
+    if (prev !== undefined)
+        t.delete(approvalId);
     t.set(approvalId, Object.freeze({ how, parked, outcome: Object.freeze({ ...outcome }) }));
     while (t.size > SETTLED_APPROVALS_MAX_ENTRIES) {
         const oldest = t.keys().next();
@@ -73,9 +174,14 @@ function noteSettled(approvalId, how, parked, outcome) {
         t.delete(oldest.value);
     }
 }
-const ENGINE_CLOSED_OUTCOME = Object.freeze({ decision: 'unresolved', retracted: true });
+function engineClosedOutcome() {
+    return Object.freeze({ kind: 'not_sent', lane: 'respond', cause: 'retracted' });
+}
 export function noteEngineClosedApproval(approvalId, parked) {
-    noteSettled(approvalId, 'closed_by_engine', parked, ENGINE_CLOSED_OUTCOME);
+    noteSettled(approvalId, 'closed_by_engine', parked, engineClosedOutcome());
+}
+export function noteHolderSettledApproval(approvalId, how, outcome) {
+    noteSettled(approvalId, how, false, outcome, true);
 }
 export function settledLiveCardOutcome(approvalId) {
     const e = settledApprovalOf(approvalId);

package/dist/hitl/approvalResolution.d.ts

@@ -1,36 +1,61 @@
 import type { DecideReceiptView } from '../decideReceipt.js';
-import type { HitlSafetyCode } from './hitlBridge.js';
-import type { FsApprovalOutcome, ToolApprovalFrameOutcome, ToolApprovalRespondAckView, ToolApprovalRespondDecision, ToolApprovalRespondParkingView } from './toolApprovalWire.js';
-export declare const APPROVAL_NOT_SENT_CAUSES: readonly ["retracted", "edit_refused", "no_pending", "fetch_failed", "no_input", "card_unavailable"];
+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';
+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"];
 export type ApprovalNotSentCause = (typeof APPROVAL_NOT_SENT_CAUSES)[number];
-export declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "decide_failed", "transport_exhausted", "safety_stop", "respond_failed", "parking_in_progress", "interrupted", "orchestration", "unreadable"];
+export declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "engine_error", "no_answer", "transport_exhausted", "parking_in_progress", "interrupted", "orchestration", "unreadable"];
 export type ApprovalUnsettledCause = (typeof APPROVAL_UNSETTLED_CAUSES)[number];
-export interface ApprovalResolutionDecided {
-    kind: 'decided';
-    decision: ToolApprovalRespondDecision;
-    gatedCallId?: string;
-    receipt?: DecideReceiptView;
-    ack?: ToolApprovalRespondAckView;
+export interface ApprovalDenyFacts {
+    readonly settledBy?: ApprovalDenySettledBy;
+    readonly reason?: string;
+    readonly attributionKey?: 'dropped' | 'renamed';
 }
-export interface ApprovalResolutionNotSent {
-    kind: 'not_sent';
-    cause: ApprovalNotSentCause;
-    gatedCallId?: string;
-    detail?: string;
+interface ApprovalResolutionBase {
+    readonly lane: ApprovalResolutionLane;
+    readonly gatedCallId?: string;
+    readonly joinedInFlight?: true;
 }
-export interface ApprovalResolutionUnsettled {
-    kind: 'unsettled';
-    cause: ApprovalUnsettledCause;
-    gatedCallId?: string;
-    safetyCode?: HitlSafetyCode;
-    errorCode?: string;
-    status?: number;
-    detail?: string;
-    parking?: ToolApprovalRespondParkingView;
+export interface ApprovalResolutionDecided extends ApprovalResolutionBase {
+    readonly kind: 'decided';
+    readonly decision: ToolApprovalRespondDecision;
+    readonly deny?: ApprovalDenyFacts;
+    readonly receipt?: DecideReceiptView;
+    readonly ack?: ToolApprovalRespondAckView;
+    readonly answered?: AskAnsweredOutput;
+}
+export interface ApprovalResolutionNotSent extends ApprovalResolutionBase {
+    readonly kind: 'not_sent';
+    readonly cause: ApprovalNotSentCause;
+    readonly safetyCode?: Exclude<HitlSafetyCode, 'binding_mismatch' | 'no_pending' | 'wrong_gate'>;
+    readonly detail?: string;
+}
+export interface ApprovalResolutionUnsettled extends ApprovalResolutionBase {
+    readonly kind: 'unsettled';
+    readonly cause: ApprovalUnsettledCause;
+    readonly safetyCode?: 'binding_mismatch';
+    readonly refusal?: DecisionRefusalReading;
+    readonly parking?: ToolApprovalRespondParkingView;
+    readonly detail?: string;
 }
 export type ApprovalResolution = ApprovalResolutionDecided | ApprovalResolutionNotSent | ApprovalResolutionUnsettled;
-export type ApprovalLegOutcome = FsApprovalOutcome | ToolApprovalFrameOutcome;
-export declare function approvalResolutionOf(outcome: ApprovalLegOutcome): ApprovalResolution;
 export declare function isApprovalDecided(r: ApprovalResolution): r is ApprovalResolutionDecided;
 export declare function approvalNotSentCause(r: ApprovalResolution): ApprovalNotSentCause | undefined;
 export declare function approvalUnsettledCause(r: ApprovalResolution): ApprovalUnsettledCause | undefined;
+export declare const APPROVAL_NOTE_RETRACTED_DETAIL = "the card was retracted (this host no longer has a decision port for it)";
+export declare const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = "edits are not accepted on this card";
+export declare function approvalResolutionDetail(r: ApprovalResolution): string | undefined;
+export declare function unsettledCauseOfReading(reading: DecisionRefusalReading): 'engine_refused' | 'engine_error' | 'no_answer';
+export interface DecisionFailureMint {
+    readonly lane: ApprovalResolutionLane;
+    readonly route: NonNullable<RefusalRouteContext['route']>;
+    readonly gatedCallId?: string | undefined;
+    readonly detail?: string | undefined;
+    readonly attributionCarried?: boolean | undefined;
+}
+export declare function resolutionOfDecisionFailure(e: {} | null | undefined, m: DecisionFailureMint): ApprovalResolution;
+export declare function joinedResolution(r: ApprovalResolution, gatedCallId?: string): ApprovalResolution;
+export {};

package/dist/hitl/approvalResolution.js

@@ -1,156 +1,120 @@
+import { DecideTransportRetryExhaustedError } from './hitlBridge.js';
+import { mintDecisionRefusalReading, refusalCarrierOf } from './decisionRefusal.js';
+import { thrownIsInstanceOf } from '../wireFailureShape.js';
+export const APPROVAL_RESOLUTION_LANES = Object.freeze(['respond', 'decide', 'ask']);
 export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'retracted',
     'edit_refused',
     'no_pending',
+    'wrong_gate',
     'fetch_failed',
     'no_input',
     'card_unavailable',
+    'safety_stop',
 ]);
 export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'engine_refused',
-    'decide_failed',
+    'engine_error',
+    'no_answer',
     'transport_exhausted',
-    'safety_stop',
-    'respond_failed',
     'parking_in_progress',
     'interrupted',
     'orchestration',
     'unreadable',
 ]);
-const FS_OUTCOME_KINDS = Object.freeze(['decided', 'aborted', 'retracted', 'failed']);
-function str(v) {
-    return typeof v === 'string' && v.length > 0 ? v : undefined;
+export function isApprovalDecided(r) {
+    return typeof r === 'object' && r !== null && r.kind === 'decided';
 }
-function num(v) {
-    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+export function approvalNotSentCause(r) {
+    if (typeof r !== 'object' || r === null || r.kind !== 'not_sent')
+        return undefined;
+    return r.cause;
 }
-function pick(o, key) {
+export function approvalUnsettledCause(r) {
+    if (typeof r !== 'object' || r === null || r.kind !== 'unsettled')
+        return undefined;
+    return r.cause;
+}
+export const APPROVAL_NOTE_RETRACTED_DETAIL = 'the card was retracted (this host no longer has a decision port for it)';
+export const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = 'edits are not accepted on this card';
+const NOT_SENT_SENTENCES = Object.freeze({
+    retracted: APPROVAL_NOTE_RETRACTED_DETAIL,
+    edit_refused: APPROVAL_NOTE_EDIT_REFUSED_DETAIL,
+    no_pending: 'there was no pending approval to decide for this run (it may already have been decided or expired); nothing was sent',
+    wrong_gate: 'the pending approval is waiting at a different kind of gate than this card; nothing was sent',
+    fetch_failed: 'the pending approval could not be fetched; nothing was sent',
+    no_input: 'the approval has no tool input or question to show, so no card was shown; nothing was sent',
+    card_unavailable: 'no approval card could be shown on this host; nothing was sent',
+    safety_stop: 'the decision was stopped by a local safety check before it was sent; nothing was sent',
+});
+function nonEmpty(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function ownStr(o, key) {
     try {
-        return o?.[key];
+        if (typeof o !== 'object' || o === null)
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d !== undefined && Object.hasOwn(d, 'value') ? nonEmpty(d.value) : undefined;
     }
     catch {
         return undefined;
     }
 }
-function opt(key, v) {
-    return v === undefined ? {} : { [key]: v };
-}
-export function approvalResolutionOf(outcome) {
-    if (typeof outcome !== 'object' || outcome === null || Array.isArray(outcome)) {
-        return { kind: 'unsettled', cause: 'unreadable' };
+export function approvalResolutionDetail(r) {
+    let kind;
+    try {
+        kind = typeof r === 'object' && r !== null ? r.kind : undefined;
     }
-    const kind = pick(outcome, 'kind');
-    if (typeof kind === 'string' && FS_OUTCOME_KINDS.includes(kind)) {
-        return fsLegResolution(outcome, kind);
+    catch {
+        return undefined;
     }
-    if (typeof pick(outcome, 'decision') === 'string') {
-        return frameLegResolution(outcome);
+    if (kind === 'not_sent') {
+        const cause = ownStr(r, 'cause');
+        if (cause === undefined || !Object.hasOwn(NOT_SENT_SENTENCES, cause))
+            return undefined;
+        const sentence = NOT_SENT_SENTENCES[cause];
+        const code = cause === 'safety_stop' ? ownStr(r, 'safetyCode') : undefined;
+        return code !== undefined ? `${sentence} (${code})` : sentence;
     }
-    return { kind: 'unsettled', cause: 'unreadable' };
-}
-function fsLegResolution(outcome, kind) {
-    const gatedCallId = str(pick(outcome, 'gatedCallId'));
-    const call = opt('gatedCallId', gatedCallId);
-    if (kind === 'decided') {
-        return {
-            kind: 'decided',
-            decision: pick(outcome, 'denied') === true ? 'deny' : 'allow',
-            ...call,
-            ...opt('receipt', pick(outcome, 'receipt')),
-        };
-    }
-    if (kind === 'retracted')
-        return { kind: 'not_sent', cause: 'retracted', ...call };
-    if (kind === 'aborted')
-        return { kind: 'unsettled', cause: 'interrupted', ...call };
-    const detail = opt('detail', str(pick(outcome, 'reason')));
-    const stage = pick(outcome, 'stage');
-    if (stage === 'fetch') {
-        const cause = pick(outcome, 'code') === 'no_pending' ? 'no_pending' : 'fetch_failed';
-        return { kind: 'not_sent', cause, ...call, ...detail };
+    if (kind !== 'unsettled')
+        return undefined;
+    let refusal;
+    try {
+        const d = Object.getOwnPropertyDescriptor(r, 'refusal');
+        refusal = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
-    if (stage === 'input')
-        return { kind: 'not_sent', cause: 'no_input', ...call, ...detail };
-    if (stage === 'card' && pick(outcome, 'editRefused') === true)
-        return { kind: 'not_sent', cause: 'edit_refused', ...call, ...detail };
-    if (stage === 'card')
-        return { kind: 'not_sent', cause: 'card_unavailable', ...call, ...detail };
-    if (stage === 'decide') {
-        const safetyCode = str(pick(outcome, 'safetyCode'));
-        const errorCode = str(pick(outcome, 'errorCode'));
-        const engineAnswered = errorCode !== undefined || pick(outcome, 'currentPending') !== undefined;
-        const cause = safetyCode !== undefined
-            ? 'safety_stop'
-            : pick(outcome, 'retryExhausted') === true
-                ? 'transport_exhausted'
-                : engineAnswered
-                    ? 'engine_refused'
-                    : 'decide_failed';
-        return {
-            kind: 'unsettled',
-            cause,
-            ...call,
-            ...opt('safetyCode', safetyCode),
-            ...opt('errorCode', errorCode),
-            ...detail,
-        };
+    catch {
+        refusal = undefined;
     }
-    if (stage === 'orchestration')
-        return { kind: 'unsettled', cause: 'orchestration', ...call, ...detail };
-    return { kind: 'unsettled', cause: 'unreadable', ...call, ...detail };
+    const parts = [ownStr(refusal, 'errorCode'), ownStr(r, 'detail') ?? ownStr(refusal, 'message')].filter((x) => x !== undefined);
+    return parts.length > 0 ? parts.join(' · ') : undefined;
 }
-function parkingViewOf(v) {
-    const approvalId = str(pick(v, 'approvalId'));
-    if (approvalId === undefined)
-        return undefined;
-    const hint = pick(v, 'retryAfterMs');
-    const retryAfterMs = typeof hint === 'number' && Number.isFinite(hint) && hint >= 0 ? hint : undefined;
-    const decidePath = str(pick(v, 'decidePath'));
-    const message = str(pick(v, 'message'));
-    return {
-        approvalId,
-        ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
-        ...(decidePath !== undefined ? { decidePath } : {}),
-        ...(message !== undefined ? { message } : {}),
-    };
+export function unsettledCauseOfReading(reading) {
+    if (reading.standing === 'ambiguous')
+        return 'engine_error';
+    return reading.standing === undefined ? 'no_answer' : 'engine_refused';
 }
-function frameLegResolution(outcome) {
-    if (pick(outcome, 'retracted') === true)
-        return { kind: 'not_sent', cause: 'retracted' };
-    if (pick(outcome, 'editRefused') === true)
-        return { kind: 'not_sent', cause: 'edit_refused' };
-    if (pick(outcome, 'aborted') === true)
-        return { kind: 'unsettled', cause: 'interrupted' };
-    const parking = parkingViewOf(pick(outcome, 'parking'));
-    if (parking !== undefined)
-        return { kind: 'unsettled', cause: 'parking_in_progress', parking };
-    if (pick(outcome, 'decision') === 'unresolved') {
-        const refusal = pick(outcome, 'respondRefusal');
-        return {
-            kind: 'unsettled',
-            cause: 'respond_failed',
-            ...opt('status', num(pick(refusal, 'status'))),
-            ...opt('errorCode', str(pick(refusal, 'errorCode'))),
-            ...opt('detail', str(pick(refusal, 'message'))),
-        };
-    }
-    const ack = pick(outcome, 'ack');
-    return {
-        kind: 'decided',
-        decision: pick(outcome, 'decision'),
-        ...(typeof ack === 'object' && ack !== null ? { ack: ack } : {}),
+export function resolutionOfDecisionFailure(e, m) {
+    const base = {
+        lane: m.lane,
+        ...(m.gatedCallId !== undefined ? { gatedCallId: m.gatedCallId } : {}),
     };
+    const detail = m.detail !== undefined && m.detail.length > 0 ? { detail: m.detail } : {};
+    const { local } = refusalCarrierOf(e);
+    if (local !== undefined && local !== 'binding_mismatch') {
+        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);
+    if (local === 'binding_mismatch')
+        return { kind: 'unsettled', ...base, cause: 'engine_refused', safetyCode: 'binding_mismatch', refusal, ...detail };
+    if (thrownIsInstanceOf(e, DecideTransportRetryExhaustedError))
+        return { kind: 'unsettled', ...base, cause: 'transport_exhausted', refusal, ...detail };
+    return { kind: 'unsettled', ...base, cause: unsettledCauseOfReading(refusal), refusal, ...detail };
 }
-export function isApprovalDecided(r) {
-    return typeof r === 'object' && r !== null && r.kind === 'decided';
-}
-export function approvalNotSentCause(r) {
-    if (typeof r !== 'object' || r === null || r.kind !== 'not_sent')
-        return undefined;
-    return r.cause;
-}
-export function approvalUnsettledCause(r) {
-    if (typeof r !== 'object' || r === null || r.kind !== 'unsettled')
-        return undefined;
-    return r.cause;
+export function joinedResolution(r, gatedCallId) {
+    const carry = r.gatedCallId === undefined && gatedCallId !== undefined && gatedCallId !== '' ? { gatedCallId } : {};
+    return { ...r, ...carry, joinedInFlight: true };
 }

package/dist/hitl/approvalsFeed.js

@@ -24,15 +24,6 @@ function readDurablePendingRows(raw) {
         return { kind: 'malformed' };
     return { kind: 'present', rows, dropped };
 }
-function baselineDurableDigestThrows(raw) {
-    try {
-        durableDigestOf(raw);
-        return false;
-    }
-    catch {
-        return true;
-    }
-}
 function durableDigestOf(rows) {
     return rows
         .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '']
@@ -214,17 +205,11 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             catch {
                 durableRead = { kind: 'malformed' };
             }
-            const badDurable = durableRead.kind === 'malformed' || durableRead.dropped > 0;
-            const escapes = badDurable && baselineDurableDigestThrows(rawPending);
-            if (durableRead.kind === 'malformed' || escapes) {
+            if (durableRead.kind === 'malformed') {
                 hostLog('debug', `approvalsFeed: list() body has an unreadable pending section (${via} leg) — snapshot not committed`);
-                if (!escapes)
-                    stats.listErrors++;
                 noteTakeMissed(via, seq);
                 publishUnknown('unreadable_payload', via, seq);
-                if (escapes)
-                    throw new TypeError('approvalsFeed: unreadable pending section (baseline digest would have thrown)');
-                return;
+                throw new TypeError('approvalsFeed: unreadable pending section');
             }
             rows = durableRead.rows;
             droppedDurable = durableRead.dropped;
@@ -246,7 +231,10 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             hostLog('debug', `approvalsFeed: dropping stale poll snapshot from leg ${leg} (current ${pollLeg}) — debt untouched`);
             return;
         }
-        noteTakeLooked(seq);
+        if (dropped > 0 || droppedDurable > 0)
+            noteTakeMissed(via, seq);
+        else
+            noteTakeLooked(seq);
         if (seq < lastObservedSeq) {
             hostLog('debug', `approvalsFeed: dropping out-of-order take #${seq} (newest observed #${lastObservedSeq})`);
             return;

package/dist/hitl/askClassPair.d.ts

@@ -1,3 +1,5 @@
+import type { CORE_MODE_ARBITRATION } from '../generated/engineFactTables.js';
+export declare const DEPLOYMENT_LIST_ASK_CLASSES: readonly (keyof typeof CORE_MODE_ARBITRATION)[];
 export type AskClassPairReading = {
     readonly state: 'pair';
     readonly askClass: string;

package/dist/hitl/askClassPair.js

@@ -1,3 +1,4 @@
+export const DEPLOYMENT_LIST_ASK_CLASSES = Object.freeze(['ask_rule']);
 const ABSENT = Object.freeze({ state: 'absent' });
 const MALFORMED = Object.freeze({ state: 'malformed' });
 export function readAskClassPairState(v) {

package/dist/hitl/askGateWire.d.ts

@@ -8,11 +8,29 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
-export type { GateOutcome, GateFailureCode } from './parkResolver.js';
+export type { GateFailureCode } from './parkResolver.js';
 export { GATE_FAILURE_CODES } from './hitlBridge.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {
     signal?: AbortSignal;
     taskId?: string;
 }): AsyncGenerator<AgentEvent>;
+export declare const LATE_DECIDE_OUTCOMES: readonly ["accepted-not-resolved", "resumed", "expired-reaped", "settled-elsewhere", "unknown"];
+export type LateDecideOutcome = (typeof LATE_DECIDE_OUTCOMES)[number];
+export interface LateDecideOutcomeReading {
+    readonly kind: LateDecideOutcome;
+    readonly taskId?: string;
+    readonly executed?: 'allowed' | 'denied';
+    readonly probeWorthy?: true;
+}
+export type LateDecideReply = {
+    readonly ok: true;
+    readonly body: object | null | undefined;
+} | {
+    readonly ok: false;
+    readonly error: object | null | undefined;
+};
+export declare function lateDecideOutcomeOf(reply: LateDecideReply, opts?: {
+    readonly lane?: 'decide' | 'respond';
+}): LateDecideOutcomeReading;