@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/hitl/hitlBridge.js

@@ -1,8 +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 { 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;
@@ -26,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)';
@@ -40,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;
@@ -79,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',
@@ -92,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;
@@ -148,7 +179,7 @@ class DecideSpan {
         }
         catch (e) {
             this.ok = false;
-            this.retryExhausted = e instanceof DecideTransportRetryExhaustedError;
+            this.retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
             throw e;
         }
         finally {
@@ -174,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)) {
@@ -208,7 +220,9 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         rows = (await client.approvals.list(opts)).pending;
     }
     catch (e) {
-        return { ok: false, reason: `approvals.list failed: ${String(e)}` };
+        const t = wireFailureTextsOf(e);
+        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 identityRow = callId !== undefined
@@ -327,13 +341,8 @@ export class HitlBridge {
             throw new HitlSafetyError(`plan-review "${outcome.decision}" must NOT carry editedPlan`, 'bad_plan_edit');
         }
         const modeAfter = outcome.permissionModeAfter;
-        if (modeAfter !== undefined) {
-            if (outcome.decision !== 'approve') {
-                throw new HitlSafetyError(`plan-review "${outcome.decision}" must NOT carry permissionModeAfter (it only applies to an approval)`, 'bad_plan_mode');
-            }
-            if (!isPlanReviewModeAfter(modeAfter)) {
-                throw new HitlSafetyError('plan-review permissionModeAfter must be "default" or "acceptEdits"', 'bad_plan_mode');
-            }
+        if (modeAfter !== undefined && !isPlanReviewModeAfter(modeAfter)) {
+            throw new HitlSafetyError('plan-review permissionModeAfter must be "default" or "acceptEdits"', 'bad_plan_mode');
         }
         const req = { decision: outcome.decision };
         if (modeAfter !== undefined && isPlanReviewModeAfter(modeAfter))
@@ -376,7 +385,7 @@ export class HitlBridge {
             return r;
         }
         catch (e) {
-            retryExhausted = e instanceof DecideTransportRetryExhaustedError;
+            retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
             throw e;
         }
         finally {
@@ -409,18 +418,21 @@ 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)) {
                     if (attempts >= DECIDE_TIMEOUT_MIN_ATTEMPTS && Date.now() - startedAt >= decideTimeoutRetryBudgetMs()) {
-                        throw new DecideTransportRetryExhaustedError(attempts, String(e));
+                        throw new DecideTransportRetryExhaustedError(attempts, wireFailureTextsOf(e).reason);
                     }
                 }
                 else if (netRetriesUsed >= 1) {
-                    throw new DecideTransportRetryExhaustedError(attempts, String(e));
+                    throw new DecideTransportRetryExhaustedError(attempts, wireFailureTextsOf(e).reason);
                 }
                 else {
                     netRetriesUsed++;
@@ -481,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.d.ts

@@ -23,6 +23,7 @@ export declare function hitlHostSurfaceFor(sessionKey: string): HitlHostSurface
 export declare function _resetHitlHostSurfaceForTest(): void;
 export declare function surfaceForCurrentSession(): HitlHostSurface | null;
 export declare const CANCEL_DENY_BUDGET_MS = 2000;
+export declare const INTERRUPT_DENY_REASON = "Interrupted by user";
 export declare const CANCEL_DENY_WARN_TEXT = "could not cancel the pending question \u2014 the session may stay locked; the run may need engine-side recovery";
 export declare const REMEMBER_NOT_APPLIED_WARN_TEXT = "this session-wide allow was not remembered by the worker \u2014 you will be asked again for this tool";
 export declare const EDIT_NOT_FORWARDED_WARN_TEXT = "your edited tool input was NOT forwarded \u2014 the tool is running with the ORIGINAL input you saw before editing";
@@ -31,6 +32,8 @@ export declare function surfaceEditNotForwarded(): void;
 export declare const APPROVAL_PARKING_WARN_TEXT = "This approval is being parked; answer it again on the parked card when it appears.";
 export declare function approvalParkingNoticeText(retryAfterMs?: number): string;
 export declare function surfaceApprovalParking(retryAfterMs?: number): void;
+export declare const COMPACT_NOT_RUNNING_WARN_TEXT = "engine run finished before compaction was applied; nothing was compacted";
+export declare function surfaceCompactNotRunning(sessionKey?: string): void;
 export declare const REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT: string;
 export declare function surfaceReplayedApprovalListUnreadable(): void;
 export declare const EDIT_REFUSED_ON_BLIND_ASK_WARN_TEXT: string;

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) {
@@ -29,22 +29,26 @@ export function _resetHitlHostSurfaceForTest() {
     hostSurfaceMissesByKey.clear();
 }
 export function surfaceForCurrentSession() {
-    const hostSurface = hitlHostSurfaceFor(DEFAULT_SESSION_KEY);
+    return surfaceForSession(DEFAULT_SESSION_KEY);
+}
+function surfaceForSession(sessionKey) {
+    const hostSurface = hitlHostSurfaceFor(sessionKey);
     if (hostSurface === null) {
-        hostSurfaceMissesByKey.set(DEFAULT_SESSION_KEY, (hostSurfaceMissesByKey.get(DEFAULT_SESSION_KEY) ?? 0) + 1);
+        hostSurfaceMissesByKey.set(sessionKey, (hostSurfaceMissesByKey.get(sessionKey) ?? 0) + 1);
     }
     return hostSurface;
 }
 export const CANCEL_DENY_BUDGET_MS = 2000;
+export const INTERRUPT_DENY_REASON = 'Interrupted by user';
 export const CANCEL_DENY_WARN_TEXT = 'could not cancel the pending question — the session may stay locked; the run may need engine-side recovery';
 const CANCEL_DENY_WARN_KEY = 'hitl-cancel-deny-warn';
 const CANCEL_DENY_WARN_TIMEOUT_MS = 10_000;
 function surfaceCancelDenyWarn(text = CANCEL_DENY_WARN_TEXT) {
     surfaceSelfClearingWarn(CANCEL_DENY_WARN_KEY, text, CANCEL_DENY_WARN_TIMEOUT_MS);
 }
-function surfaceSelfClearingWarn(key, text, timeoutMs) {
+function surfaceSelfClearingWarn(key, text, timeoutMs, sessionKey = DEFAULT_SESSION_KEY) {
     try {
-        const s = surfaceForCurrentSession();
+        const s = surfaceForSession(sessionKey);
         if (!s)
             return;
         s.showNotice({ key, text, color: 'warning', priority: 'immediate', timeoutMs });
@@ -83,6 +87,12 @@ export function approvalParkingNoticeText(retryAfterMs) {
 export function surfaceApprovalParking(retryAfterMs) {
     surfaceSelfClearingWarn(APPROVAL_PARKING_KEY, approvalParkingNoticeText(retryAfterMs), APPROVAL_PARKING_TIMEOUT_MS);
 }
+export const COMPACT_NOT_RUNNING_WARN_TEXT = 'engine run finished before compaction was applied; nothing was compacted';
+const COMPACT_NOT_RUNNING_KEY = 'engine-compact-not-running';
+const COMPACT_NOT_RUNNING_TIMEOUT_MS = 10_000;
+export function surfaceCompactNotRunning(sessionKey = DEFAULT_SESSION_KEY) {
+    surfaceSelfClearingWarn(COMPACT_NOT_RUNNING_KEY, COMPACT_NOT_RUNNING_WARN_TEXT, COMPACT_NOT_RUNNING_TIMEOUT_MS, sessionKey);
+}
 export const REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT = "Could not read the pending-approval list, so an approval request read back from this run's event log was not raised as a question, " +
     'and no decision was sent for it.';
 const REPLAYED_APPROVAL_LIST_UNREADABLE_KEY = 'hitl-replayed-approval-list-unreadable';
@@ -123,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) => {
@@ -142,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.js

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

package/dist/hitl/noAllowCause.d.ts

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

package/dist/hitl/noAllowCause.js

@@ -0,0 +1,26 @@
+import { automaticAnswerVerdict } from './automaticAnswerVerdict.js';
+function ladderSays(ladder, key) {
+    if (typeof ladder !== 'object' || ladder === null)
+        return false;
+    try {
+        const d = Object.getOwnPropertyDescriptor(ladder, key);
+        return d !== undefined && 'value' in d && d.value === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function noAllowCauseOf(card, ladder) {
+    if (ladderSays(ladder, 'allowed') || ladderSays(ladder, 'denied'))
+        return undefined;
+    if (ladderSays(ladder, 'askRuleMatched'))
+        return 'ask_rule';
+    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 (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;
@@ -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;