@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/hitl/gateLedger.js

@@ -13,6 +13,8 @@ export function hasLedgerPositionKey(ev) {
     return (id !== undefined && id !== null) || (seq !== undefined && seq !== null);
 }
 export const PREAMBLE_APPROVALS_MAX_ENTRIES = 4096;
+export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
+export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 export const START_ARGS_MAX_ENTRIES = 256;
 function normalizeDenyAttribution(a) {
     if (a === undefined)
@@ -88,6 +90,7 @@ export function createGateLedger() {
     let denyStampAttribution;
     let seq;
     const preambleApprovalIds = new Set();
+    const settledApprovalHows = new Map();
     const liveCards = new Set();
     return {
         noteSeq(ev) {
@@ -121,6 +124,24 @@ export function createGateLedger() {
         beginStreamSegment() {
             preambleApprovalIds.clear();
         },
+        noteApprovalSettled(approvalId, how) {
+            if (typeof approvalId !== 'string' || approvalId === '')
+                return;
+            if (!APPROVAL_SETTLED_HOWS.includes(how))
+                return;
+            if (settledApprovalHows.has(approvalId))
+                return;
+            settledApprovalHows.set(approvalId, how);
+            while (settledApprovalHows.size > SETTLED_APPROVALS_MAX_ENTRIES) {
+                const oldest = settledApprovalHows.keys().next();
+                if (oldest.done === true)
+                    break;
+                settledApprovalHows.delete(oldest.value);
+            }
+        },
+        settledApprovals() {
+            return settledApprovalHows;
+        },
         trackLiveCard(phaseOf, handled) {
             const entry = { phaseOf, handled };
             liveCards.add(entry);

package/dist/hitl/hitlBridge.d.ts

@@ -46,7 +46,8 @@ export interface PlanReviewOutcome {
 export declare const PLAN_REVIEW_MODE_AFTER_WORDS: readonly ["default", "acceptEdits"];
 export type PlanReviewModeAfter = (typeof PLAN_REVIEW_MODE_AFTER_WORDS)[number];
 export declare function isPlanReviewModeAfter(v: string | undefined): v is PlanReviewModeAfter;
-export type HitlSafetyCode = 'binding_mismatch' | 'no_pending' | 'wrong_gate' | 'bad_plan_edit' | 'bad_plan_mode' | 'empty_answer';
+export declare const GATE_FAILURE_CODES: readonly ["no_pending", "binding_mismatch", "wrong_gate", "bad_plan_edit", "bad_plan_mode", "empty_answer"];
+export type HitlSafetyCode = (typeof GATE_FAILURE_CODES)[number];
 export type HitlFailureStage = 'fetch' | 'input' | 'card' | 'decide' | 'orchestration';
 export declare const NO_APPROVAL_CARD_PORT_REASON = "no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)";
 export declare const APPROVAL_CARD_PORT_KEY_MISMATCH_REASON = "no approval card port installed for the default session key, but a non-default sessionKey has one \u2014 likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install";
@@ -62,9 +63,19 @@ export declare class HitlSafetyError extends Error {
     readonly code: HitlSafetyCode;
     constructor(message: string, code: HitlSafetyCode);
 }
+export declare function hitlSafetyCodeOf(e: unknown): HitlSafetyCode | undefined;
 export type GateCurrentPending = Readonly<NonNullable<ApprovalStaleError['currentPending']>>;
 export declare function readDecideCurrentPending(e: unknown): GateCurrentPending | undefined;
 export declare function readWireErrorCode(e: unknown): string | undefined;
+export type WireErrorCodeReading = {
+    readonly state: 'code';
+    readonly code: string;
+} | {
+    readonly state: 'absent';
+} | {
+    readonly state: 'unreadable';
+};
+export declare function readWireErrorCodeReading(e: unknown): WireErrorCodeReading;
 export declare function __setDecideTimeoutRetryBudgetForTests(ms?: number): void;
 export declare class DecideTransportRetryExhaustedError extends Error {
     readonly attempts: number;

package/dist/hitl/hitlBridge.js

@@ -1,9 +1,11 @@
 import { askParkForeignGateKind } from '../adapter/activeRunSelfHeal.js';
 import { eventSeq } from '../adapter/types.js';
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { abortableSleep } from '../abortableSleep.js';
 import { readOwnDataValue } from '../ownKey.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { THROWN_SLOT_UNREADABLE, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { decisionConflictOf } from './decisionConflict.js';
 import { suspendedReopenOf } from './suspendedReopen.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 const MAX_DENY_REASON_CHARS = 4096;
@@ -27,6 +29,14 @@ export const PLAN_REVIEW_MODE_AFTER_WORDS = Object.freeze(['default', 'acceptEdi
 export function isPlanReviewModeAfter(v) {
     return v !== undefined && PLAN_REVIEW_MODE_AFTER_WORDS.includes(v);
 }
+export const GATE_FAILURE_CODES = [
+    'no_pending',
+    'binding_mismatch',
+    'wrong_gate',
+    'bad_plan_edit',
+    'bad_plan_mode',
+    'empty_answer',
+];
 export const NO_APPROVAL_CARD_PORT_REASON = 'no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)';
 export const APPROVAL_CARD_PORT_KEY_MISMATCH_REASON = 'no approval card port installed for the default session key, but a non-default sessionKey has one — likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install';
 export const NO_QUESTION_OVERLAY_REASON = 'no question overlay mounted (print/non-REPL mode)';
@@ -41,28 +51,46 @@ export class HitlSafetyError extends Error {
         this.name = 'HitlSafetyError';
     }
 }
+export function hitlSafetyCodeOf(e) {
+    if (!thrownIsInstanceOf(e, HitlSafetyError))
+        return undefined;
+    const raw = readThrownSlot(e, 'code');
+    return typeof raw === 'string' && GATE_FAILURE_CODES.includes(raw) ? raw : undefined;
+}
 const _gateCurrentPendingReadonlyPin = true;
 void _gateCurrentPendingReadonlyPin;
 export function readDecideCurrentPending(e) {
-    const raw = e?.currentPending;
+    if (e === null || e === undefined)
+        return undefined;
+    const raw = readThrownSlot(e, 'currentPending');
     if (typeof raw !== 'object' || raw === null)
         return undefined;
-    const o = raw;
-    if (typeof o.toolName !== 'string' || o.toolName.length === 0)
+    const toolName = readThrownSlot(raw, 'toolName');
+    const boundCallId = readThrownSlot(raw, 'boundCallId');
+    const boundInputHash = readThrownSlot(raw, 'boundInputHash');
+    if (typeof toolName !== 'string' || toolName.length === 0)
         return undefined;
-    if (typeof o.boundCallId !== 'string' || o.boundCallId.length === 0)
+    if (typeof boundCallId !== 'string' || boundCallId.length === 0)
         return undefined;
     return {
-        toolName: o.toolName,
-        boundCallId: o.boundCallId,
-        ...(typeof o.boundInputHash === 'string' && o.boundInputHash.length > 0
-            ? { boundInputHash: o.boundInputHash }
+        toolName,
+        boundCallId,
+        ...(typeof boundInputHash === 'string' && boundInputHash.length > 0
+            ? { boundInputHash }
             : {}),
     };
 }
 export function readWireErrorCode(e) {
-    const raw = e?.errorCode;
-    return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+    const reading = readWireErrorCodeReading(e);
+    return reading.state === 'code' ? reading.code : undefined;
+}
+export function readWireErrorCodeReading(e) {
+    if (e === null || e === undefined)
+        return { state: 'absent' };
+    const raw = readThrownSlot(e, 'errorCode');
+    if (raw === THROWN_SLOT_UNREADABLE)
+        return { state: 'unreadable' };
+    return typeof raw === 'string' && raw.length > 0 ? { state: 'code', code: raw } : { state: 'absent' };
 }
 const DECIDE_TRANSPORT_RETRY_BACKOFF_MS = 750;
 const DECIDE_RETRY_BACKOFF_MAX_MS = 5_000;
@@ -80,10 +108,9 @@ function decideTimeoutRetryBudgetMs() {
 function isDecideAttemptTimeout(e, depth = 0) {
     if (depth > 3 || e === null || typeof e !== 'object')
         return false;
-    const o = e;
-    if (o.name === 'TimeoutError')
+    if (readThrownSlot(e, 'name') === 'TimeoutError')
         return true;
-    return isDecideAttemptTimeout(o.cause, depth + 1);
+    return isDecideAttemptTimeout(readThrownSlot(e, 'cause'), depth + 1);
 }
 const TRANSIENT_NETWORK_CODES = new Set([
     'ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN',
@@ -93,18 +120,21 @@ const TRANSIENT_NETWORK_CODES = new Set([
 function isTransientDecideTransportFailure(e, depth = 0) {
     if (depth > 3 || e === null || typeof e !== 'object')
         return false;
-    if (e instanceof HitlSafetyError)
+    if (thrownIsInstanceOf(e, HitlSafetyError))
         return false;
-    const o = e;
-    if (typeof o.status === 'number')
+    const status = readThrownSlot(e, 'status');
+    if (status === THROWN_SLOT_UNREADABLE || typeof status === 'number')
         return false;
-    if (o.name === 'TimeoutError' || o.name === 'AbortError')
+    const name = readThrownSlot(e, 'name');
+    if (name === 'TimeoutError' || name === 'AbortError')
         return true;
-    if (typeof o.code === 'string' && TRANSIENT_NETWORK_CODES.has(o.code))
+    const code = readThrownSlot(e, 'code');
+    if (typeof code === 'string' && TRANSIENT_NETWORK_CODES.has(code))
         return true;
-    if (typeof o.message === 'string' && o.message.toLowerCase().includes('fetch failed'))
+    const message = readThrownSlot(e, 'message');
+    if (typeof message === 'string' && message.toLowerCase().includes('fetch failed'))
         return true;
-    return isTransientDecideTransportFailure(o.cause, depth + 1);
+    return isTransientDecideTransportFailure(readThrownSlot(e, 'cause'), depth + 1);
 }
 export class DecideTransportRetryExhaustedError extends Error {
     attempts;
@@ -149,7 +179,7 @@ class DecideSpan {
         }
         catch (e) {
             this.ok = false;
-            this.retryExhausted = e instanceof DecideTransportRetryExhaustedError;
+            this.retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
             throw e;
         }
         finally {
@@ -175,32 +205,13 @@ class DecideSpan {
         notifyDecideObserver(this.observer, Object.freeze({ ...this.identity, phase: 'end', ok: this.ok, attempts: this.attempts, retryExhausted: this.retryExhausted }));
     }
 }
-function reportObserverFault(phase, what, e) {
-    try {
-        hostLog('debug', `hitlBridge: onDecideOperation(${phase}) ${what}: ${String(e).slice(0, 160)}`);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function wireOptsOf(opts) {
     if (opts === undefined || opts.operation === undefined)
         return opts;
     return opts.signal !== undefined ? { signal: opts.signal } : undefined;
 }
 function notifyDecideObserver(observer, ev) {
-    try {
-        const out = observer(ev);
-        if (out && typeof out.then === 'function') {
-            void Promise.resolve(out).then(undefined, (e) => {
-                reportObserverFault(ev.phase, 'rejected', e);
-            });
-        }
-    }
-    catch (e) {
-        reportObserverFault(ev.phase, 'threw', e);
-    }
+    invokeHostCallbackIsolated(`hitlBridge: onDecideOperation(${ev.phase})`, () => observer(ev));
 }
 const ANY_TOOL_FAMILY = () => true;
 export async function findPendingForTask(client, taskId, matches, opts, callId, identityAccepts = (r) => matches(typeof r.toolName === 'string' ? r.toolName : undefined)) {
@@ -374,7 +385,7 @@ export class HitlBridge {
             return r;
         }
         catch (e) {
-            retryExhausted = e instanceof DecideTransportRetryExhaustedError;
+            retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
             throw e;
         }
         finally {
@@ -407,9 +418,12 @@ export class HitlBridge {
                 return r;
             }
             catch (e) {
-                if (isBindingMismatch(e)) {
+                const binding = bindingMismatchReading(e);
+                if (binding === 'mismatch') {
                     throw new HitlSafetyError('approval_binding_mismatch — the pending action changed under the human; refetch + re-present', 'binding_mismatch');
                 }
+                if (binding === 'unreadable')
+                    throw e;
                 if (!isTransientDecideTransportFailure(e) || callerAborted())
                     throw e;
                 if (isDecideAttemptTimeout(e)) {
@@ -479,16 +493,17 @@ function marshalAnswer(a) {
         entry.note = a.note;
     return entry;
 }
-function isBindingMismatch(e) {
+function bindingMismatchReading(e) {
     if (!e || typeof e !== 'object')
-        return false;
-    const o = e;
-    const code = o.errorCode;
-    if (code === 'approval_binding_mismatch')
-        return true;
-    if (typeof o.name === 'string' && o.name === 'ApprovalBindingMismatchError')
-        return true;
-    return false;
+        return 'not';
+    const code = readWireErrorCodeReading(e);
+    const name = readThrownSlot(e, 'name');
+    const family = (code.state === 'code' && code.code === 'approval_binding_mismatch') || name === 'ApprovalBindingMismatchError';
+    if (family)
+        return decisionConflictOf(e) !== 'answer_invalid' ? 'mismatch' : 'not';
+    if (code.state === 'unreadable')
+        return 'unreadable';
+    return 'not';
 }
 export function backendDeny(reason) {
     return {

package/dist/hitl/hitlHostSurface.js

@@ -2,7 +2,7 @@ import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
 import { decideFailureNote } from '../decideFailureNote.js';
-import { HitlSafetyError } from './hitlBridge.js';
+import { decisionRefusalSaysAskGone } from './decisionRefusal.js';
 const hostSurfaceByKey = createSessionSlot();
 const hostSurfaceMissesByKey = new Map();
 export function installHitlHostSurface(surface) {
@@ -133,14 +133,6 @@ const RULE_NOT_SENT_REJECTED_TIMEOUT_MS = 10_000;
 export function surfaceRuleArmRejected(why) {
     surfaceSelfClearingWarn(RULE_NOT_SENT_REJECTED_KEY, ruleNotSentRejectedText(why), RULE_NOT_SENT_REJECTED_TIMEOUT_MS);
 }
-function isNoPendingError(e) {
-    if (e instanceof HitlSafetyError)
-        return e.code === 'no_pending';
-    if (typeof e !== 'object' || e === null || !('code' in e))
-        return false;
-    const code = e.code;
-    return typeof code === 'string' && code === 'no_pending';
-}
 export function observeCancelByDeny(settle, taskId) {
     let timer;
     const budget = new Promise((_, reject) => {
@@ -152,8 +144,8 @@ export function observeCancelByDeny(settle, taskId) {
         hostLog('debug', `[hitl-cancel-deny] cancel-by-deny settled for run ${taskId} (session unlocked)`);
     })
         .catch((e) => {
-        if (isNoPendingError(e)) {
-            hostLog('debug', `[hitl-cancel-deny] cancel-by-deny no_pending for run ${taskId} (benign — already resolved)`);
+        if (decisionRefusalSaysAskGone(e)) {
+            hostLog('debug', `[hitl-cancel-deny] cancel-by-deny found the question no longer pending for run ${taskId} (benign — settled elsewhere, parked or gone)`);
             return;
         }
         const rowNote = decideFailureNote(e, 'deny');

package/dist/hitl/livePendingAsk.d.ts

@@ -22,16 +22,26 @@ export type LivePendingReading = {
     dropped: number;
 };
 export declare function readLivePendingRows(body: unknown): LivePendingReading;
-export interface SuspendedAskFilter {
-    sessionId?: string;
-}
-export declare function suspendedSubagentAsks(snapshot: ApprovalsFeedEmission | null | undefined, filter?: SuspendedAskFilter): LivePendingAskView[];
+export type SuspendedAskFilter = {
+    readonly sessionId: string;
+    readonly allSessions?: never;
+    readonly identityPending?: never;
+} | {
+    readonly allSessions: true;
+    readonly sessionId?: never;
+    readonly identityPending?: never;
+} | {
+    readonly identityPending: true;
+    readonly sessionId?: never;
+    readonly allSessions?: never;
+};
+export declare function suspendedSubagentAsks(snapshot: ApprovalsFeedEmission | null | undefined, filter: SuspendedAskFilter): LivePendingAskView[];
 export interface ApprovalsAwaitingDecisionCount {
     durable: number | null;
     live: number | null;
     suspendedSubagent: number | null;
 }
-export declare function countApprovalsAwaitingDecision(snapshot: ApprovalsFeedEmission | null | undefined, filter?: SuspendedAskFilter): ApprovalsAwaitingDecisionCount;
+export declare function countApprovalsAwaitingDecision(snapshot: ApprovalsFeedEmission | null | undefined, filter: SuspendedAskFilter): ApprovalsAwaitingDecisionCount;
 export declare function livePendingRowToApprovalFrame(row: LivePendingAskView): ToolApprovalFrame;
 export declare function surfaceSuspendedAskAndRespond(row: LivePendingAskView, respond: RespondToolApprovalFn, signal?: AbortSignal, lane?: ToolApprovalFrameLaneOpts): Promise<ToolApprovalFrameOutcome>;
 export interface SuspendedAskDelta {
@@ -45,4 +55,4 @@ export interface SuspendedAskTracker {
     requeue(approvalId: string): void;
     noteDecided(approvalId: string): void;
 }
-export declare function createSuspendedAskTracker(filter?: SuspendedAskFilter): SuspendedAskTracker;
+export declare function createSuspendedAskTracker(filter: SuspendedAskFilter): SuspendedAskTracker;

package/dist/hitl/livePendingAsk.js

@@ -1,3 +1,4 @@
+import { THROWN_SLOT_UNREADABLE, readThrownSlot } from '../wireFailureShape.js';
 import { isToolApprovalFrame, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
 function nonEmptyString(v) {
     return typeof v === 'string' && v !== '';
@@ -69,20 +70,48 @@ export function readLivePendingRows(body) {
         return { kind: 'malformed' };
     return { kind: 'present', rows, dropped };
 }
-export function suspendedSubagentAsks(snapshot, filter) {
+const IDENTITY_PENDING_SCOPE = Object.freeze({ kind: 'identity_pending' });
+function suspendedAskScopeOf(filter) {
+    if (typeof filter !== 'object' || filter === null)
+        return IDENTITY_PENDING_SCOPE;
+    const sessionId = readThrownSlot(filter, 'sessionId', true);
+    const allSessions = readThrownSlot(filter, 'allSessions', true);
+    const identityPending = readThrownSlot(filter, 'identityPending', true);
+    if (sessionId === THROWN_SLOT_UNREADABLE || allSessions === THROWN_SLOT_UNREADABLE || identityPending === THROWN_SLOT_UNREADABLE)
+        return IDENTITY_PENDING_SCOPE;
+    const sessionOk = typeof sessionId === 'string' && sessionId !== '';
+    const allOk = allSessions === true;
+    const pendingOk = identityPending === true;
+    if ((sessionId !== undefined && !sessionOk) || (allSessions !== undefined && !allOk) || (identityPending !== undefined && !pendingOk))
+        return IDENTITY_PENDING_SCOPE;
+    if (sessionOk && !allOk && !pendingOk)
+        return { kind: 'session', sessionId };
+    if (allOk && !sessionOk && !pendingOk)
+        return { kind: 'all' };
+    return IDENTITY_PENDING_SCOPE;
+}
+function subagentAsksIn(snapshot, scope) {
+    if (scope.kind === 'identity_pending')
+        return [];
     if (snapshot?.kind === 'unknown')
         return [];
     const rows = snapshot?.livePending;
     if (!Array.isArray(rows))
         return [];
-    return rows.filter(r => r.fromSubagent === true && (filter?.sessionId === undefined || r.sessionId === filter.sessionId));
+    return rows.filter(r => r.fromSubagent === true && (scope.kind === 'all' || r.sessionId === scope.sessionId));
+}
+export function suspendedSubagentAsks(snapshot, filter) {
+    return subagentAsksIn(snapshot, suspendedAskScopeOf(filter));
 }
 export function countApprovalsAwaitingDecision(snapshot, filter) {
+    const scope = suspendedAskScopeOf(filter);
+    if (scope.kind === 'identity_pending')
+        return { durable: null, live: null, suspendedSubagent: null };
     if (snapshot === null || snapshot === undefined)
         return { durable: null, live: null, suspendedSubagent: null };
     if (snapshot.kind === 'unknown')
         return { durable: null, live: null, suspendedSubagent: null };
-    const bySession = (rows) => filter?.sessionId === undefined ? [...rows] : rows.filter(r => r.sessionId === filter.sessionId);
+    const bySession = (rows) => scope.kind === 'session' ? rows.filter(r => r.sessionId === scope.sessionId) : [...rows];
     const durable = (snapshot.pendingDropped ?? 0) > 0 ? null : Array.isArray(snapshot.pending) ? bySession(snapshot.pending).length : null;
     if (!Array.isArray(snapshot.livePending))
         return { durable, live: null, suspendedSubagent: null };
@@ -113,6 +142,7 @@ export function surfaceSuspendedAskAndRespond(row, respond, signal, lane) {
 }
 const TRACKER_UNSEEN_CLAIMS_MAX = 512;
 export function createSuspendedAskTracker(filter) {
+    const scope = suspendedAskScopeOf(filter);
     const shown = new Set();
     const shownWithFrame = new Set();
     const claimed = new Map();
@@ -137,7 +167,9 @@ export function createSuspendedAskTracker(filter) {
         ingest(snapshot) {
             if (snapshot?.kind === 'unknown')
                 return { appeared: [], gone: [], upgraded: [] };
-            const rows = suspendedSubagentAsks(snapshot, filter);
+            if (scope.kind === 'identity_pending')
+                return { appeared: [], gone: [], upgraded: [] };
+            const rows = subagentAsksIn(snapshot, scope);
             const present = new Set(rows.map(r => r.approvalId));
             const appeared = [];
             const upgraded = [];

package/dist/hitl/parkExpiryJudgements.d.ts

@@ -0,0 +1,19 @@
+export type ApprovalCompleteDisposition = 'live-expired-parked' | 'live-expired-retract' | 'settled' | null;
+export declare function classifyApprovalCompleteFrame(frame: unknown): ApprovalCompleteDisposition;
+export type ParkRowDeadlineState = {
+    kind: 'none';
+} | {
+    kind: 'pending';
+    deadlineMs: number;
+    remainingMs: number;
+} | {
+    kind: 'past';
+    deadlineMs: number;
+    remainingMs: number;
+};
+export declare function parkRowDeadlineState(row: unknown, nowMs: number): ParkRowDeadlineState;
+export declare function lateDecideRoute(o: {
+    windowClosed: boolean;
+    durableRowFound: boolean;
+}): 'decide' | 'respond';
+export declare function runReapedByDeadline(client: unknown, taskId: string): Promise<boolean>;

package/dist/hitl/parkExpiryJudgements.js

@@ -0,0 +1,46 @@
+import { APPROVAL_EXPIRED } from '../engineErrorCodes.js';
+import { approvalCompleteParked } from './approvalCompleteParked.js';
+export function classifyApprovalCompleteFrame(frame) {
+    if (typeof frame !== 'object' || frame === null)
+        return null;
+    const f = frame;
+    if (f.type !== 'tool_approval_complete')
+        return null;
+    const outcome = f.outcome;
+    if (outcome === 'allowed' || outcome === 'denied')
+        return 'settled';
+    if (outcome !== 'expired')
+        return null;
+    return approvalCompleteParked(frame) ? 'live-expired-parked' : 'live-expired-retract';
+}
+const PARK_DEADLINE_MAX_SANE_MS = 24 * 60 * 60 * 1000;
+export function parkRowDeadlineState(row, nowMs) {
+    if (typeof row !== 'object' || row === null)
+        return { kind: 'none' };
+    const raw = row.deadline;
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0)
+        return { kind: 'none' };
+    const remainingMs = raw - nowMs;
+    if (remainingMs > PARK_DEADLINE_MAX_SANE_MS)
+        return { kind: 'none' };
+    return remainingMs > 0
+        ? { kind: 'pending', deadlineMs: raw, remainingMs }
+        : { kind: 'past', deadlineMs: raw, remainingMs };
+}
+export function lateDecideRoute(o) {
+    if (!o.windowClosed)
+        return 'respond';
+    return o.durableRowFound ? 'decide' : 'respond';
+}
+export async function runReapedByDeadline(client, taskId) {
+    try {
+        const runs = client?.runs;
+        if (typeof runs?.get !== 'function')
+            return false;
+        const rec = (await runs.get(taskId));
+        return rec?.errorCode === APPROVAL_EXPIRED;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hitl/parkResolver.d.ts

@@ -1,7 +1,6 @@
 import type { AgentEvent } from '@sema-agent/sdk';
-import { type GateCurrentPending, type HitlFailureStage } from './hitlBridge.js';
+import { type GateCurrentPending, type HitlFailureStage, type HitlSafetyCode } from './hitlBridge.js';
 import { type QuestionAnswer } from '../liveQuestionStore.js';
-import { type FsApprovalOutcome } from './toolApprovalWire.js';
 import type { AskAnsweredOutput, GateLedger } from './gateLedger.js';
 import { type AskGateWireDeps, type GatePark } from './frameRouter.js';
 import { type DecideReceiptView } from '../decideReceipt.js';
@@ -13,8 +12,7 @@ export interface HopBudget {
 }
 export declare function nextHopBudget(prev: HopBudget | undefined, round: HopRound): HopBudget;
 export declare const MAX_TOTAL_PARKS = 64;
-export declare const GATE_FAILURE_CODES: readonly ["no_pending", "binding_mismatch", "wrong_gate", "bad_plan_edit", "bad_plan_mode", "empty_answer"];
-export type GateFailureCode = (typeof GATE_FAILURE_CODES)[number];
+export type GateFailureCode = HitlSafetyCode;
 export type GateOutcome = {
     kind: 'decided';
     gatedCallId?: string | undefined;
@@ -35,9 +33,7 @@ export type GateOutcome = {
     currentPending?: GateCurrentPending | undefined;
 };
 export declare function isAlreadyResolvedGateReason(reason: unknown): boolean;
-export declare function isAlreadyResolvedFailure(outcome: Extract<GateOutcome | FsApprovalOutcome, {
-    kind: 'failed';
-}>): boolean;
+export declare function isAlreadyResolvedFailure(failure: unknown): boolean;
 export declare function isGateStandingErrorCode(code: string | null | undefined, retriable?: boolean): boolean;
 export declare function isCodeClassifiedGateFailure(code: string | null | undefined, retriable?: boolean): boolean;
 export declare function toAnsweredOutput(questions: unknown[], answer: QuestionAnswer): AskAnsweredOutput;