@sema-agent/client-core 0.94.0 → 0.96.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", "binding_missing"];
+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,23 @@ 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 readWireCodes(e: unknown): {
+    readonly errorCode?: string;
+    readonly blockedBy?: string;
+};
 export declare function __setDecideTimeoutRetryBudgetForTests(ms?: number): void;
 export declare class DecideTransportRetryExhaustedError extends Error {
     readonly attempts: number;
@@ -105,7 +120,7 @@ export type FindPendingOutcome = {
 } | {
     ok: false;
     reason: string;
-    code?: 'no_pending';
+    code?: 'no_pending' | 'wrong_gate';
 };
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;

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, readBlockedBy, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.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,15 @@ 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 = Object.freeze([
+    'no_pending',
+    'binding_mismatch',
+    'wrong_gate',
+    'bad_plan_edit',
+    'bad_plan_mode',
+    'empty_answer',
+    'binding_missing',
+]);
 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 +52,55 @@ 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' };
+}
+export function readWireCodes(e) {
+    const reading = readWireErrorCodeReading(e);
+    if (reading.state !== 'code')
+        return {};
+    if (reading.code !== RESUME_POLICY_FOLD_CODE)
+        return { errorCode: reading.code };
+    const folded = readBlockedBy(e);
+    return folded.kind === 'named' ? { errorCode: reading.code, blockedBy: folded.code } : { errorCode: reading.code };
 }
 const DECIDE_TRANSPORT_RETRY_BACKOFF_MS = 750;
 const DECIDE_RETRY_BACKOFF_MAX_MS = 5_000;
@@ -80,10 +118,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 +130,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 +189,7 @@ class DecideSpan {
         }
         catch (e) {
             this.ok = false;
-            this.retryExhausted = e instanceof DecideTransportRetryExhaustedError;
+            this.retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
             throw e;
         }
         finally {
@@ -175,32 +215,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)) {
@@ -213,10 +234,21 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         hostLog('debug', `hitlBridge: approvals.list failed: ${t.log}`);
         return { ok: false, reason: `approvals.list failed: ${t.reason}` };
     }
-    const decidable = rows.filter((r) => askParkForeignGateKind(r) === null);
+    const readings = rows.map((r) => ({ r, foreign: askParkForeignGateKind(r) }));
+    const decidable = readings.filter((x) => x.foreign === null).map((x) => x.r);
     const identityRow = callId !== undefined
         ? decidable.find((r) => r.taskId === taskId && (r.boundCallId === callId || r.toolCallId === callId))
         : undefined;
+    const identityForeign = callId !== undefined && identityRow === undefined
+        ? readings.find((x) => x.r.taskId === taskId && (x.r.boundCallId === callId || x.r.toolCallId === callId) && x.foreign !== null)
+        : undefined;
+    if (identityForeign !== undefined) {
+        return {
+            ok: false,
+            reason: `the pending row this park names (call ${callId}) is parked on a '${String(identityForeign.foreign)}' gate — not an approval this leg decides; refusing to decide a different row`,
+            code: 'wrong_gate',
+        };
+    }
     const identityConflicts = identityRow !== undefined && !identityAccepts(identityRow);
     const pool = identityConflicts ? decidable.filter((r) => identityAccepts(r)) : decidable;
     const pending = (identityConflicts ? undefined : identityRow) ??
@@ -275,7 +307,7 @@ export class HitlBridge {
         if (p.boundCallId === undefined || p.boundInputHash === undefined) {
             throw new HitlSafetyError(`pending checkpoint ${p.id ?? '<no-id>'} is missing D-1 binding fields ` +
                 `(boundCallId=${String(p.boundCallId)}, boundInputHash=${String(p.boundInputHash)}) — ` +
-                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_mismatch');
+                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_missing');
         }
         return { boundCallId: p.boundCallId, boundInputHash: p.boundInputHash };
     }
@@ -374,7 +406,7 @@ export class HitlBridge {
             return r;
         }
         catch (e) {
-            retryExhausted = e instanceof DecideTransportRetryExhaustedError;
+            retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
             throw e;
         }
         finally {
@@ -407,9 +439,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 +514,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 'mismatch';
+    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/localAllowRule.d.ts

@@ -6,6 +6,7 @@ export interface LocalAllowRuleDeps {
     bashRuleContentHasDangerousBarePrefix(ruleContent: string): boolean;
     isDangerousBashPermission(toolName: string, ruleContent: string): boolean;
     isDangerousPowerShellPermission(toolName: string, ruleContent: string): boolean;
+    onFailure?(log: string): void;
 }
 export type LocalAllowRuleParse = {
     ok: true;

package/dist/hitl/localAllowRule.js

@@ -1,4 +1,4 @@
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { reasonOfThrownWithSink } from '../hostCallbackGuard.js';
 const BASH_TOOL_NAME_FOR_RULES = 'Bash';
 export function parseLocalAllowRule(rule, expectedToolName, deps) {
     if (typeof rule !== 'string' || rule === '') {
@@ -9,7 +9,7 @@ export function parseLocalAllowRule(rule, expectedToolName, deps) {
         value = deps.parseRule(rule);
     }
     catch (e) {
-        return { ok: false, error: `rule text did not parse (${wireFailureTextsOf(e).reason})` };
+        return { ok: false, error: `rule text did not parse (${reasonOfThrownWithSink(e, (log) => deps.onFailure?.(log))})` };
     }
     if (typeof value.toolName !== 'string' || value.toolName === '') {
         return { ok: false, error: 'rule text carries no tool name' };

package/dist/hitl/noAllowCause.d.ts

@@ -1,9 +1,10 @@
-export type NoAllowCause = 'no_allow_rule' | 'ask_rule' | 'budget' | 'other';
+export type NoAllowCause = 'no_allow_rule' | 'ask_rule' | 'engine_ask_rule' | 'budget' | 'other';
 export interface RuleLadderNoAllowFacts {
     readonly allowed?: boolean;
     readonly denied?: boolean;
     readonly askRuleMatched?: boolean;
     readonly budgetExhausted?: boolean;
     readonly noRuleMatched?: boolean;
+    readonly noAskRuleMatched?: boolean;
 }
 export declare function noAllowCauseOf(card: object | null | undefined, ladder: RuleLadderNoAllowFacts | null | undefined): NoAllowCause | undefined;

package/dist/hitl/noAllowCause.js

@@ -18,8 +18,9 @@ export function noAllowCauseOf(card, ladder) {
     if (ladderSays(ladder, 'budgetExhausted'))
         return 'budget';
     const standing = automaticAnswerVerdict(card, 'standing_rule');
-    if (standing.kind === 'must_ask' && (standing.askClass === 'ask_rule' || standing.origin === 'ask_rule'))
-        return 'ask_rule';
+    if (standing.kind === 'must_ask' && (standing.askClass === 'ask_rule' || standing.origin === 'ask_rule')) {
+        return ladderSays(ladder, 'noAskRuleMatched') || ladderSays(ladder, 'noRuleMatched') ? 'engine_ask_rule' : 'ask_rule';
+    }
     if (ladderSays(ladder, 'noRuleMatched') && standing.kind === 'may_answer')
         return 'no_allow_rule';
     return 'other';

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;
@@ -30,14 +28,13 @@ export type GateOutcome = {
     reason: string;
     code?: GateFailureCode | undefined;
     errorCode?: string | undefined;
+    blockedBy?: string | undefined;
     retriable?: true;
     retryExhausted?: true;
     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;