@sema-agent/client-core 0.96.0 → 0.97.1

package/dist/hitl/askGateWire.js

@@ -60,6 +60,7 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
                 gate: action.gate,
                 ...(action.pendingDone !== undefined ? { pendingDone: action.pendingDone } : {}),
                 ...(action.gatedCallId !== undefined ? { gatedCallId: action.gatedCallId } : {}),
+                ...(action.toolName !== undefined ? { toolName: action.toolName } : {}),
             };
             break;
         }

package/dist/hitl/automaticAnswerVerdict.js

@@ -3,7 +3,6 @@ import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from
 import { mandatedApprovalDetail } from '../gateVocabulary.js';
 import { readAskOrigin, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPairState } from './askClassPair.js';
-import { currentEngineWord } from '../engineWordRenames.js';
 import { approvalAllowRuleShadowed } from './allowRuleShadow.js';
 import { approvalIsMandated, readApprovalMandate } from './toolApprovalWire.js';
 export const MODE_ARBITRATION = CORE_MODE_ARBITRATION;
@@ -19,8 +18,7 @@ const ORIGIN_IMPLIES_CLASS = Object.freeze({
 function mandateWordClass(raw) {
     if (raw === 'operator_always')
         return 'shell_floor';
-    const word = currentEngineWord(raw);
-    return Object.hasOwn(TABLE, word) ? word : undefined;
+    return Object.hasOwn(TABLE, raw) ? raw : undefined;
 }
 const ORDINARY_ROW = CORE_MODE_ARBITRATION.ordinary;
 function bypassImmuneOn(c, face) {
@@ -44,8 +42,8 @@ export function foldModeArbitrationRow(classes, askFace) {
     let ruleMayClear = true;
     let hookAskFloor = false;
     for (const raw of classes) {
-        const c = typeof raw === 'string' ? currentEngineWord(raw) : raw;
-        if (!Object.hasOwn(TABLE, c))
+        const c = raw;
+        if (typeof c !== 'string' || !Object.hasOwn(TABLE, c))
             continue;
         const row = TABLE[c];
         any = true;
@@ -133,7 +131,7 @@ export function automaticAnswerVerdict(card, lane, facts) {
             return UNKNOWN.classes_malformed;
         if (pair.state === 'absent')
             return UNKNOWN.classes_absent;
-        const classes = pair.classes.map(currentEngineWord);
+        const classes = pair.classes;
         const folded = foldModeArbitrationRow(classes, face);
         let anyKnown = false;
         let firstBlocking;
@@ -172,7 +170,7 @@ export function mandatedApprovalDetailOf(card) {
         const pair = readAskClassPairState(card);
         if (pair.state !== 'pair')
             return mandatedApprovalDetail();
-        const classes = pair.classes.map(currentEngineWord);
+        const classes = pair.classes;
         if (classes.some((c) => !Object.hasOwn(TABLE, c)))
             return mandatedApprovalDetail();
         const row = foldModeArbitrationRow(classes);

package/dist/hitl/decisionConflict.js

@@ -1,4 +1,5 @@
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
+import { ownDataField } from '../ownKey.js';
 import { readRefusalField } from '../wireFailureShape.js';
 const BINDING_SEAT_FIELDS = new Set(['boundCallId', 'boundInputHash']);
 const ANSWER_FIELD = 'answer';
@@ -9,13 +10,13 @@ export function decisionConflictOf(err) {
     let code;
     let name;
     try {
-        code = err.errorCode;
+        code = ownDataField(err, 'errorCode');
     }
     catch {
-        code = undefined;
+        return undefined;
     }
     try {
-        name = err.name;
+        name = ownDataField(err, 'name');
     }
     catch {
         name = undefined;

package/dist/hitl/decisionRefusal.js

@@ -1,10 +1,10 @@
-import { ApprovalStaleError, AskDecidedError, ParkedResumeStartupError } from '@sema-agent/sdk';
 import { ASK_GONE, ASK_GONE_PARKED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
 import { notPendingCauseReading } from './approvalEndingCause.js';
 import { GATE_FAILURE_CODES } from './hitlBridge.js';
 import { isAlreadyResolvedGateReason, isCodeClassifiedGateFailure } from './parkResolver.js';
 import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
+import { ownDataField } from '../ownKey.js';
 import { readToolApprovalRespondRefusal } from './toolApprovalWire.js';
 const ASK_DECIDED_CODE = 'conflict.ask_decided';
 const TRANSIENT_STATUSES = new Set([408, 425, 429, 502, 503, 504]);
@@ -13,22 +13,27 @@ export function decisionRefusalSaysAskGone(err) {
     return readDecisionRefusalAsk(err).reading === 'settled';
 }
 const facts = (reading, gateMoved = false, wordingHint = false) => ({ reading, gateMoved, wordingHint });
+const PROTOCOL_ERROR_NAMES = Object.freeze({
+    askDecided: 'AskDecidedError',
+    approvalStale: 'ApprovalStaleError',
+    parkedResumeStartup: 'ParkedResumeStartupError',
+});
 export function readDecisionRefusalAsk(failure) {
     if (typeof failure !== 'object' || failure === null)
         return facts('not_settled');
     let flattened, localCode, name, errorCode, status, retriable, text;
     try {
-        const o = failure;
-        if (Object.hasOwn(failure, 'unreadable') && failure.unreadable === true)
+        const slot = (key) => ownDataField(failure, key);
+        if (slot('unreadable') === true)
             return facts('unreadable');
-        flattened = Object.hasOwn(failure, 'kind') && o.kind === 'failed';
+        flattened = slot('kind') === 'failed';
         const closed = (v) => (typeof v === 'string' && GATE_FAILURE_CODES.includes(v) ? v : undefined);
-        localCode = flattened ? (closed(o.code) ?? closed(o.safetyCode)) : closed(o.code);
-        name = flattened ? undefined : o.name;
-        errorCode = o.errorCode;
-        status = o.status;
+        localCode = flattened ? (closed(slot('code')) ?? closed(slot('safetyCode'))) : closed(slot('code'));
+        name = flattened ? undefined : slot('name');
+        errorCode = slot('errorCode');
+        status = slot('status');
         retriable = refusalRetriableReading(failure);
-        text = flattened ? o.reason : String(failure);
+        text = flattened ? slot('reason') : String(failure);
     }
     catch {
         return facts('unreadable');
@@ -40,15 +45,17 @@ export function readDecisionRefusalAsk(failure) {
     if (name === 'HitlSafetyError')
         return facts('not_settled');
     const code = typeof errorCode === 'string' && errorCode.length > 0 ? errorCode : undefined;
+    if (isCodeClassifiedGateFailure(code, retriable))
+        return facts('not_settled');
     const st = typeof status === 'number' && Number.isInteger(status) && status >= 400 && status <= 599 ? status : undefined;
     if (code === ASK_DECIDED_CODE || code === ASK_GONE || (st === 410 && code !== ASK_GONE_PARKED))
         return facts('settled');
     if (st === 404 && notPendingCauseReading(failure) === 'ended')
         return facts('settled');
-    if (code === undefined && name === AskDecidedError.name)
+    if (code === undefined && name === PROTOCOL_ERROR_NAMES.askDecided)
         return facts('settled');
-    const gateMoved = isDecideAlreadyResolvedCode(code) || isDecideParkMovedCode(code) || code === ASK_GONE_PARKED || (code === undefined && name === ApprovalStaleError.name);
-    if (gateMoved || st !== undefined || name === ParkedResumeStartupError.name || isCodeClassifiedGateFailure(code, retriable))
+    const gateMoved = isDecideAlreadyResolvedCode(code) || isDecideParkMovedCode(code) || code === ASK_GONE_PARKED || (code === undefined && name === PROTOCOL_ERROR_NAMES.approvalStale);
+    if (gateMoved || st !== undefined || name === PROTOCOL_ERROR_NAMES.parkedResumeStartup)
         return facts('not_settled', gateMoved);
     return facts('not_settled', false, isAlreadyResolvedGateReason(text));
 }

package/dist/hitl/frameRouter.d.ts

@@ -40,6 +40,7 @@ export interface GatePark {
     gate: GateKind;
     pendingDone?: AgentEvent | undefined;
     gatedCallId?: string | undefined;
+    toolName?: string | undefined;
 }
 export type FrameAction = {
     kind: 'yield';
@@ -51,6 +52,7 @@ export type FrameAction = {
     gate: GateKind;
     pendingDone?: AgentEvent | undefined;
     gatedCallId?: string | undefined;
+    toolName?: string | undefined;
 } | {
     kind: 'end';
     events: readonly AgentEvent[];
@@ -65,6 +67,7 @@ export interface FrameRouterCtx {
     signal?: AbortSignal | undefined;
 }
 export declare function isAskTool(toolName: string | undefined): boolean;
+export declare function parkGateArmOf(gate: unknown): GateKind | null;
 export declare function isHostProgressFrame(ev: AgentEvent): boolean;
 interface HeldFlushInterruptEvidence {
     terminal?: AgentEvent | undefined;

package/dist/hitl/frameRouter.js

@@ -1,12 +1,12 @@
 import { hostLog } from '../host.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
-import { isToolApprovalGate, toolNameIsFsWrite, toolNameIsShellExec, isToolApprovalFrame, isFromSubagent, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
+import { toolNameIsFsWrite, toolNameIsShellExec, isToolApprovalFrame, isFromSubagent, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
 import { classifierDenyFromToolEnd } from '../classifierVerdictWire.js';
 import { toolEndOutputText } from '../toolResultContent.js';
 import { GATE_PARKED_ERROR_CODE } from '../engineErrorCodes.js';
 import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateToolName } from '../runTerminal.js';
 import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from './hitlHostSurface.js';
-import { liveCardAnsweredHow, liveCardHoldOf, supersedeLiveCard } from './approvalHolds.js';
+import { liveCardHoldOf, noteEngineClosedApproval, supersedeLiveCard } from './approvalHolds.js';
 import { approvalCompleteParked } from './approvalCompleteParked.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { SEMA_DENIAL_KIND_KEY, hasLedgerPositionKey } from './gateLedger.js';
@@ -15,6 +15,7 @@ import { settleWithinDeadline } from '../abortableSleep.js';
 import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
 import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
 import { RUN_CANCELLED_CODE } from '../runCancelContext.js';
+import { durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
 export const HITL_REJECT_MESSAGE = REJECT_MESSAGE;
 export const HITL_POLICY_DENY_MESSAGE = 'Permission for this tool use was denied: it requires interactive approval, and permission prompts are ' +
     'not available in this session. The action was NOT performed. Do not claim it succeeded, and do not retry ' +
@@ -99,6 +100,27 @@ function parkFamilyEvidence(led, gateToolName, gatedCallId) {
         return false;
     return gatedCallId === undefined || led.isFsOrShellGatedCall(gatedCallId);
 }
+export function parkGateArmOf(gate) {
+    if (gate === null || typeof gate !== 'object')
+        return null;
+    let kind;
+    let toolName;
+    try {
+        kind = gate.kind;
+        toolName = gate.toolName;
+    }
+    catch {
+        return null;
+    }
+    const leg = durableDecideLegOf(typeof kind === 'string' ? { gateKind: kind } : null);
+    if (leg !== 'approval' && leg !== 'absent')
+        return null;
+    if (isAskToolLoose(toolName))
+        return 'ask';
+    if (leg === 'approval')
+        return 'fs';
+    return isFsOrShellToolName(toolName) ? 'fs' : null;
+}
 const ENGINE_GATE_PARKED_ERROR_CODE = GATE_PARKED_ERROR_CODE;
 function isEngineAbortToolEnd(ev) {
     if (ev.errorCode === ENGINE_GATE_PARKED_ERROR_CODE)
@@ -123,11 +145,8 @@ function parkGateOf(result) {
     if (typeof taskId !== 'string' || taskId.length === 0)
         return null;
     const toolName = runTerminalGateToolName(read);
-    if (isAskToolLoose(toolName))
-        return { taskId, gate: 'ask', toolName };
-    if (isToolApprovalGate({ kind: runTerminalGateKind(read), toolName }))
-        return { taskId, gate: 'fs', toolName };
-    return null;
+    const arm = parkGateArmOf({ kind: runTerminalGateKind(read), toolName });
+    return arm === null ? null : { taskId, gate: arm, toolName };
 }
 function parkGatedCallId(src) {
     const v = src?.toolCallId;
@@ -264,18 +283,19 @@ async function routeToolApprovalFrame(ev, ctx) {
     const { led, deps } = ctx;
     if (ev.type === 'tool_approval_complete') {
         const id = ev.approvalId;
-        if (typeof id === 'string' && id !== '' && supersedeLiveCard(liveFrameCallKey(id), approvalCompleteParked(ev))) {
+        const parked = approvalCompleteParked(ev);
+        if (typeof id === 'string' && id !== '')
+            noteEngineClosedApproval(id, parked);
+        if (typeof id === 'string' && id !== '' && supersedeLiveCard(liveFrameCallKey(id), parked)) {
             hostLog('debug', `liveHitlAskWire: tool_approval_complete for ${id} arrived while its card was waiting — card withdrawn (nothing will be sent from it)`);
         }
-        if (typeof id === 'string' && id !== '')
-            led.noteApprovalSettled(id, 'closed_by_engine');
         return { kind: 'skip' };
     }
     if (!deps.respondToolApproval) {
         hostLog('debug', `liveHitlAskWire: tool_approval frame ${ev.approvalId} but no respond wire — engine self-settles (TTL deny)`);
         return { kind: 'skip' };
     }
-    const settledHere = settledApprovalDisposition(ev, led.settledApprovals());
+    const settledHere = settledApprovalDisposition(ev);
     if (settledHere !== undefined || (hasLedgerPositionKey(ev) && !led.preambleApprovals().has(ev.approvalId))) {
         const disposition = settledHere ?? (await judgeLedgerApprovalFrame(ev, ctx));
         if (disposition.kind !== 'live') {
@@ -298,21 +318,17 @@ async function routeToolApprovalFrame(ev, ctx) {
     const gatedCallId = fromSubagent ? undefined : frameCallId ?? led.lastPendingFsCall();
     const argsCallId = frameCallId === undefined ? gatedCallId : typeof ev.toolName === 'string' && toolNameIsFsWrite(ev.toolName) ? frameCallId : undefined;
     const runTaskId = ctx.taskId.current;
-    const approvalIdAtLaunch = ev.approvalId;
     const launched = surfaceToolApprovalFrameAndRespond(ev, deps.respondToolApproval, argsOfGatedStart(led, argsCallId), ctx.signal, deps.approvalLane, typeof runTaskId === 'string' && runTaskId !== '' ? { taskId: runTaskId } : undefined);
     const hold = liveCardHoldOf(liveFrameCallKey(ev.approvalId));
-    const handled = launched.then((outcome) => settleLiveCardOutcome(ev, approvalIdAtLaunch, outcome, ctx, fromSubagent, gatedCallId), (e) => {
+    const handled = launched.then((outcome) => settleLiveCardOutcome(ev, outcome, ctx, fromSubagent, gatedCallId), (e) => {
         hostLog('debug', `liveHitlAskWire: tool_approval card for ${ev.approvalId} failed: ${String(e).slice(0, 160)}`);
     });
     led.trackLiveCard(() => hold?.phase ?? 'card', handled);
     return { kind: 'skip' };
 }
-function settleLiveCardOutcome(ev, approvalId, outcome, ctx, fromSubagent, gatedCallId) {
+function settleLiveCardOutcome(ev, outcome, ctx, fromSubagent, gatedCallId) {
     const { led, deps } = ctx;
     const { decision } = outcome;
-    const settledHow = liveCardAnsweredHow(outcome);
-    if (settledHow !== undefined)
-        led.noteApprovalSettled(approvalId, settledHow);
     if (deps.onToolApprovalOutcome !== undefined) {
         invokeHostCallbackIsolated('liveHitlAskWire: onToolApprovalOutcome', () => deps.onToolApprovalOutcome?.(ev, outcome));
     }
@@ -349,7 +365,7 @@ async function judgeLedgerApprovalFrame(ev, ctx) {
             .finally(release);
     });
     const approvals = got.kind === 'value' ? { read: 'ok', body: got.value } : { read: 'failed' };
-    return replayedApprovalDisposition(ev, { preamble: ctx.led.preambleApprovals(), approvals, settled: ctx.led.settledApprovals() });
+    return replayedApprovalDisposition(ev, { preamble: ctx.led.preambleApprovals(), approvals });
 }
 function routeToolStart(ev, callId, led) {
     led.noteStart(callId, ev);
@@ -382,15 +398,20 @@ function routeToolEnd(ev, callId, led) {
 }
 function routeSuspended(ev, ctx) {
     const gatedCallId = parkGatedCallId(ev);
-    if (ev.gate && isAskToolLoose(ev.gate.toolName) && ctx.taskId.current) {
+    const arm = parkGateArmOf(ev.gate);
+    if (arm === 'ask' && ctx.taskId.current) {
         ctx.led.noteParkGate({ fsOrShellFamily: false });
         return { kind: 'park', gate: 'ask', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
-    if (ev.gate &&
-        isToolApprovalGate(ev.gate) &&
-        ctx.taskId.current) {
-        ctx.led.noteParkGate({ fsOrShellFamily: parkFamilyEvidence(ctx.led, ev.gate.toolName, gatedCallId) });
-        return { kind: 'park', gate: 'fs', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
+    if (arm === 'fs' && ctx.taskId.current) {
+        const gateToolName = ev.gate?.toolName;
+        ctx.led.noteParkGate({ fsOrShellFamily: parkFamilyEvidence(ctx.led, gateToolName, gatedCallId) });
+        return {
+            kind: 'park',
+            gate: 'fs',
+            ...(gatedCallId !== undefined ? { gatedCallId } : {}),
+            ...(typeof gateToolName === 'string' && gateToolName !== '' ? { toolName: gateToolName } : {}),
+        };
     }
     return { kind: 'yield', events: [ev] };
 }
@@ -401,7 +422,13 @@ function routeDone(ev, ctx) {
     if (park !== null) {
         ctx.taskId.current = ctx.taskId.current ?? park.taskId;
         led.noteParkGate({ fsOrShellFamily: park.gate === 'fs' && parkFamilyEvidence(led, park.toolName, gatedCallId) });
-        return { kind: 'park', gate: park.gate, pendingDone: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
+        return {
+            kind: 'park',
+            gate: park.gate,
+            pendingDone: ev,
+            ...(gatedCallId !== undefined ? { gatedCallId } : {}),
+            ...(park.toolName !== undefined && park.toolName !== '' ? { toolName: park.toolName } : {}),
+        };
     }
     const events = [...flushHeldWithInterruptRewrite(led, { terminal: ev, signal: ctx.signal })];
     const r = ev.result;

package/dist/hitl/gateLedger.d.ts

@@ -16,9 +16,6 @@ export interface AskAnsweredOutput {
 export declare function durableSeqOf(ev: object): string | undefined;
 export declare function hasLedgerPositionKey(ev: object): boolean;
 export declare const PREAMBLE_APPROVALS_MAX_ENTRIES = 4096;
-export declare const APPROVAL_SETTLED_HOWS: readonly ["answered", "interrupted", "closed_by_engine"];
-export type ApprovalSettledHow = (typeof APPROVAL_SETTLED_HOWS)[number];
-export declare const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 export interface GateLedger {
     noteSeq(ev: AgentEvent): void;
     lastSeq(): string | undefined;
@@ -26,8 +23,6 @@ export interface GateLedger {
     notePreambleApproval(approvalId: string): void;
     preambleApprovals(): ReadonlySet<string>;
     beginStreamSegment(): void;
-    noteApprovalSettled(approvalId: string, how: ApprovalSettledHow): void;
-    settledApprovals(): ReadonlyMap<string, ApprovalSettledHow>;
     trackLiveCard(phaseOf: () => 'card' | 'respond', handled: Promise<void>): void;
     answeringLiveCards(): Promise<void>[];
     liveCardsSettled(): Promise<void>;

package/dist/hitl/gateLedger.js

@@ -13,8 +13,6 @@ 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)
@@ -90,7 +88,6 @@ export function createGateLedger() {
     let denyStampAttribution;
     let seq;
     const preambleApprovalIds = new Set();
-    const settledApprovalHows = new Map();
     const liveCards = new Set();
     return {
         noteSeq(ev) {
@@ -124,24 +121,6 @@ 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.js

@@ -3,7 +3,7 @@ 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 { ownDataField, readOwnDataValue } from '../ownKey.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';
@@ -55,7 +55,13 @@ export class HitlSafetyError extends Error {
 export function hitlSafetyCodeOf(e) {
     if (!thrownIsInstanceOf(e, HitlSafetyError))
         return undefined;
-    const raw = readThrownSlot(e, 'code');
+    let raw;
+    try {
+        raw = ownDataField(e, 'code');
+    }
+    catch {
+        return undefined;
+    }
     return typeof raw === 'string' && GATE_FAILURE_CODES.includes(raw) ? raw : undefined;
 }
 const _gateCurrentPendingReadonlyPin = true;
@@ -88,9 +94,17 @@ export function readWireErrorCode(e) {
 export function readWireErrorCodeReading(e) {
     if (e === null || e === undefined)
         return { state: 'absent' };
-    const raw = readThrownSlot(e, 'errorCode');
-    if (raw === THROWN_SLOT_UNREADABLE)
+    let raw;
+    try {
+        if (typeof e === 'object' || typeof e === 'function') {
+            raw = ownDataField(e, 'errorCode');
+            if (raw === undefined && !Object.hasOwn(e, 'errorCode'))
+                void e.errorCode;
+        }
+    }
+    catch {
         return { state: 'unreadable' };
+    }
     return typeof raw === 'string' && raw.length > 0 ? { state: 'code', code: raw } : { state: 'absent' };
 }
 export function readWireCodes(e) {

package/dist/hitl/parkResolver.js

@@ -1,6 +1,7 @@
 import { putOwnKey, readOwnDataValue } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, GATE_FAILURE_CODES, HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, hitlSafetyCodeOf, isNoDecisionSurfaceReason, readDecideCurrentPending, readWireCodes, } from './hitlBridge.js';
-import { DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isRefusedParkCode, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, isRefusedParkCode, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { RESUME_REFUSAL_CODES } from '../resumeRefusalCopy.js';
 import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
@@ -45,11 +46,14 @@ export function isGateStandingErrorCode(code, retriable) {
     return (code === RESUME_POLICY_FOLD_CODE ||
         code === 'corrupt' ||
         (isRefusedParkCode(code) && retriable === true) ||
+        (typeof code === 'string' && RESUME_REOPEN_CODES.includes(code) && retriable === true) ||
         code === DECIDE_WORKFLOW_PARKS_UNREADABLE ||
         code === DECIDE_WORKFLOW_PARK_FORKED);
 }
 export function isCodeClassifiedGateFailure(code, retriable) {
-    return isGateStandingErrorCode(code, retriable) || code === PARKED_RESUME_STARTUP_FAILED;
+    return (isGateStandingErrorCode(code, retriable) ||
+        code === PARKED_RESUME_STARTUP_FAILED ||
+        (typeof code === 'string' && (RESUME_RETRY_LATER_CODES.includes(code) || RESUME_REFUSAL_CODES.includes(code))));
 }
 export function toAnsweredOutput(questions, answer) {
     const answers = {};
@@ -189,7 +193,7 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
             ...(onPresented ? { onPresented } : {}),
             ...(deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : {}),
             ...(decidedByReading !== undefined ? { approvalDecidedBy: decidedByReading } : {}),
-        }, taskId, argsByCallOf(led), ctx.signal, gatedCallId);
+        }, taskId, argsByCallOf(led), ctx.signal, gatedCallId, park.toolName);
         const outcomeDenied = 'denied' in outcome ? outcome.denied : undefined;
         if (outcome.kind === 'decided' && outcomeDenied === true && outcome.gatedCallId) {
             const denySettledBy = 'denySettledBy' in outcome ? outcome.denySettledBy : undefined;

package/dist/hitl/replayedApproval.d.ts

@@ -1,4 +1,4 @@
-import { type ApprovalSettledHow } from './gateLedger.js';
+import { type ApprovalSettledHow } from './approvalHolds.js';
 import { type ApprovalsListEnvelope, type CrashConvergedRow } from './crashConverged.js';
 export type ReplayedApprovalDisposition = {
     readonly kind: 'live';
@@ -20,9 +20,8 @@ export interface ReplayPendingBasis {
     } | {
         readonly read: 'failed';
     };
-    readonly settled?: ReadonlyMap<string, ApprovalSettledHow>;
 }
-export declare function settledApprovalDisposition(frame: object, settled: ReplayPendingBasis['settled']): ReplayedApprovalDisposition | undefined;
+export declare function settledApprovalDisposition(frame: object): ReplayedApprovalDisposition | undefined;
 export declare function replayedApprovalDisposition(frame: object, basis: ReplayPendingBasis): ReplayedApprovalDisposition;
 export declare function replayedApprovalClosesCardFrame(disposition: ReplayedApprovalDisposition | null | undefined): boolean;
 export declare function replayedApprovalSentence(disposition: ReplayedApprovalDisposition | undefined, opts?: {

package/dist/hitl/replayedApproval.js

@@ -1,4 +1,5 @@
-import { APPROVAL_SETTLED_HOWS, hasLedgerPositionKey } from './gateLedger.js';
+import { hasLedgerPositionKey } from './gateLedger.js';
+import { anyApprovalSettled, settledApprovalOf } from './approvalHolds.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { projectCrashConverged } from './crashConverged.js';
 import { quoteUntrustedForSentence } from '../displayUntrusted.js';
@@ -23,15 +24,12 @@ function crashConvergedFactsOf(body, approvalId) {
     }
     return undefined;
 }
-export function settledApprovalDisposition(frame, settled) {
+export function settledApprovalDisposition(frame) {
     try {
-        if (typeof settled !== 'object' || settled === null || typeof settled.get !== 'function')
+        if (!anyApprovalSettled())
             return undefined;
-        const id = approvalIdOf(frame);
-        if (id === undefined)
-            return undefined;
-        const how = settled.get(id);
-        return typeof how === 'string' && APPROVAL_SETTLED_HOWS.includes(how) ? decidedSettled(how) : undefined;
+        const entry = settledApprovalOf(approvalIdOf(frame));
+        return entry === undefined ? undefined : decidedSettled(entry.how);
     }
     catch {
         return undefined;
@@ -48,14 +46,7 @@ export function replayedApprovalDisposition(frame, basis) {
     catch {
         return unknown('unreadable_frame');
     }
-    let settledBasis;
-    try {
-        settledBasis = typeof basis === 'object' && basis !== null ? basis.settled : undefined;
-    }
-    catch {
-        settledBasis = undefined;
-    }
-    const early = settledApprovalDisposition(frame, settledBasis);
+    const early = settledApprovalDisposition(frame);
     if (early !== undefined)
         return early;
     try {

package/dist/hitl/sessionPolicyDeliverable.d.ts

@@ -15,7 +15,6 @@ export interface SessionPolicyDeliverability {
 export interface SessionPolicyDeliverableOptions {
     readonly roster?: ToolRosterView;
 }
-export { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 export declare function sessionPolicyDeliverable(behavior: 'deny' | 'ask', rules: readonly string[], opts?: SessionPolicyDeliverableOptions): SessionPolicyDeliverability;
 export declare function sessionPolicyWithheldNotice(why: SessionPolicyWithheldWhy): string;
 export declare function legacyToolNameFailureNoteOf(code: string | undefined): string | undefined;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -3,10 +3,8 @@ import { rosterMountedNames } from '../rosterMountedNames.js';
 import { ruleCompileVerdict } from '../ruleCompileVerdict.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX, RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
-import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from '../generated/toolNameTables.js';
-import { isEngineRefusedToolName } from '../engineRefusedToolName.js';
+import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
 const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
-const ENGINE_RETIRED_TOOL_NAMES = CORE_RETIRED_TOOL_CURRENT_NAMES;
 const WITHHELD_NOTICE = {
     ask_no_bucket: 'Not written to this session’s rule record: that record only holds rules that block outright, and this rule asks before running instead — recording it as a block would change what it means.',
     qualified_deny: 'Not written to this session’s rule record: that record holds whole tool names and command names only, and this rule has a part in parentheses it cannot carry — recording just the name could block more than this rule does.',
@@ -37,11 +35,8 @@ function withheldWhyOf(rule) {
     }
     if (rule.trim() !== rule)
         return 'not_a_tool_name';
-    if (isEngineRefusedToolName(rule))
-        return 'legacy_tool_name';
     return undefined;
 }
-export { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 function suppliedRosterNames(opts) {
     if (opts === undefined || opts === null)
         return 'absent';
@@ -95,29 +90,32 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
             continue;
         }
         let why = withheldWhyOf(r);
+        let currentName;
         if (why === undefined) {
-            const grammar = ruleCompileVerdict(r, 'deny').kind;
-            if (grammar === 'unknown')
+            const verdict = ruleToolNameVerdictOf(r);
+            if (verdict.kind === 'unknown')
                 return unreadable();
-            if (grammar === 'refused')
+            if (verdict.kind === 'retired' || verdict.kind === 'unprefixed_namespace') {
+                why = 'legacy_tool_name';
+                if (verdict.kind === 'retired')
+                    currentName = verdict.currentName;
+            }
+            else if (verdict.kind === 'unmintable_segment')
                 why = 'not_a_tool_name';
         }
-        if (why === undefined && COVERING_NAMESPACE_PREFIXES.some((p) => r.startsWith(p))) {
-            const verdict = ruleToolNameVerdictOf(r);
-            if (verdict.kind === 'unknown')
+        if (why === undefined) {
+            const grammar = ruleCompileVerdict(r, 'deny').kind;
+            if (grammar === 'unknown')
                 return unreadable();
-            if (verdict.kind === 'unmintable_segment')
+            if (grammar === 'refused')
                 why = 'not_a_tool_name';
-            else if (verdict.kind === 'retired' || verdict.kind === 'unprefixed_namespace')
-                why = 'legacy_tool_name';
         }
         if (why === undefined && mounted !== undefined && !mounted.has(r))
             why = 'not_in_roster';
         if (why === undefined)
             exact.push(r);
         else {
-            const currentName = why === 'legacy_tool_name' ? ENGINE_RETIRED_TOOL_NAMES.get(r) : undefined;
-            withheld.push(typeof currentName === 'string' ? { rule: r, why, currentName } : { rule: r, why });
+            withheld.push(why === 'legacy_tool_name' && currentName !== undefined ? { rule: r, why, currentName } : { rule: r, why });
         }
     }
     if (withheld.length > 0 || exact.length === 0)

package/dist/hitl/sessionPolicyWire.d.ts

@@ -132,6 +132,8 @@ export type SessionPolicyRemovalOutcome = {
 } | {
     kind: 'nothing_to_remove';
     rev: number;
+} | {
+    kind: 'judge_failed';
 } | {
     kind: 'loosen_forbidden';
     message: string;