@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/hitl/decisionRefusal.js

@@ -1,39 +1,125 @@
-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 { ASK_GONE, ASK_GONE_PARKED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { notPendingCauseReading, refusalCauseWordOf } from './approvalEndingCause.js';
+import { GATE_FAILURE_CODES, readDecideCurrentPending, readWireCodes } 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';
+import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
+import { PROTOCOL_ERROR_NAME, isDisplayableWireCode, protocolErrorNameReading, readErrorRecord, readRefusalField } from '../wireFailureShape.js';
+import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
 const ASK_DECIDED_CODE = 'conflict.ask_decided';
 const TRANSIENT_STATUSES = new Set([408, 425, 429, 502, 503, 504]);
-const DISPLAYABLE_CODE = /^[A-Za-z0-9._:-]{1,64}$/;
+export function refusalCarrierOf(err) {
+    if (typeof err !== 'object' || err === null)
+        return { carrier: err };
+    const name = guardedRead(() => readOwnDataValue(err, 'name'));
+    if (name !== 'HitlSafetyError')
+        return { carrier: err };
+    const code = guardedRead(() => readOwnDataValue(err, 'code'));
+    const local = typeof code === 'string' && GATE_FAILURE_CODES.includes(code) ? code : undefined;
+    const cause = guardedRead(() => readOwnDataValue(err, 'cause'));
+    const carrier = typeof cause === 'object' && cause !== null ? cause : err;
+    return local !== undefined ? { local, carrier } : { carrier };
+}
+const ROUTE_WORDS = { approval_decide: true, live_respond: true, ask_decide: true, plan_review: true, compact: true };
+const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
+const PRIOR_REFUSAL_EVIDENCE = Object.freeze([
+    Object.freeze({
+        errorCode: 'corrupt',
+        routes: Object.freeze(['plan_review', 'approval_decide', 'live_respond']),
+        evidence: 'server resume-legs.ts:1019 / :2752 / :2910 (resume context read, before the claim CAS at :1666 / :1457); plan_review resumePlanReview reads context before settling',
+    }),
+]);
+function routeOf(context) {
+    const r = guardedRead(() => (typeof context === 'object' && context !== null ? readOwnDataValue(context, 'route') : undefined));
+    return typeof r === 'string' && REFUSAL_ROUTES.includes(r) ? r : undefined;
+}
+function carrierStatus(carrier) {
+    const raw = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataValue(carrier, 'status')) : undefined;
+    return typeof raw === 'number' && Number.isFinite(raw) ? raw : undefined;
+}
+function carrierCode(carrier) {
+    const raw = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataValue(carrier, 'errorCode')) : undefined;
+    return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+}
+export function refusalDeliveryOf(err, context) {
+    const { carrier } = refusalCarrierOf(err);
+    const status = carrierStatus(carrier);
+    const errorCode = carrierCode(carrier);
+    const facts = { ...(status !== undefined ? { status } : {}), ...(errorCode !== undefined ? { errorCode } : {}) };
+    if (status === undefined || !Number.isInteger(status) || status < 400 || status > 599)
+        return { delivery: 'no_answer', ...facts };
+    const route = routeOf(context);
+    if (route !== undefined && errorCode !== undefined && PRIOR_REFUSAL_EVIDENCE.some((p) => p.errorCode === errorCode && p.routes.includes(route))) {
+        return { delivery: 'refused', ...facts };
+    }
+    if (status < 500 || status === 501)
+        return { delivery: 'refused', ...facts };
+    return { delivery: 'ambiguous', ...facts };
+}
 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',
-});
+function preflightSettledBitsPresent(carrier) {
+    const detail = guardedRead(() => readErrorRecord(carrier, 'detail'));
+    if (detail === undefined)
+        return false;
+    const bit = (k) => guardedRead(() => readOwnDataValue(detail, k));
+    const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+    return nonEmpty(bit('settledBy')) || nonEmpty(bit('rowStatus'));
+}
+const RESOLUTION_KINDS = Object.freeze(['decided', 'not_sent', 'unsettled']);
+const ASK_READINGS = Object.freeze(['settled', 'not_settled', 'unreadable']);
+function isResolutionShaped(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const kind = guardedRead(() => readOwnDataValue(v, 'kind'));
+    return typeof kind === 'string' && RESOLUTION_KINDS.includes(kind);
+}
+function askFactsOfResolution(r) {
+    try {
+        const kind = ownDataField(r, 'kind');
+        if (kind === 'not_sent')
+            return facts(ownDataField(r, 'cause') === 'no_pending' ? 'settled' : 'not_settled');
+        if (kind !== 'unsettled')
+            return facts('not_settled');
+        const refusal = ownDataField(r, 'refusal');
+        if (typeof refusal !== 'object' || refusal === null)
+            return facts('not_settled');
+        const ask = ownDataField(refusal, 'ask');
+        if (typeof ask !== 'string' || !ASK_READINGS.includes(ask))
+            return facts('unreadable');
+        return facts(ask, ownDataField(refusal, 'gateMoved') === true, ownDataField(refusal, 'wordingHint') === true);
+    }
+    catch {
+        return facts('unreadable');
+    }
+}
 export function readDecisionRefusalAsk(failure) {
     if (typeof failure !== 'object' || failure === null)
         return facts('not_settled');
-    let flattened, localCode, name, errorCode, status, retriable, text;
+    if (isResolutionShaped(failure))
+        return askFactsOfResolution(failure);
+    const { local, carrier } = refusalCarrierOf(failure);
+    if (local !== undefined)
+        return facts(local === 'no_pending' ? 'settled' : 'not_settled');
+    if (typeof carrier !== 'object' || carrier === null)
+        return facts('not_settled');
+    let localCode, name, protocolName, errorCode, status, retriable, text;
     try {
-        const slot = (key) => ownDataField(failure, key);
-        if (slot('unreadable') === true)
-            return facts('unreadable');
-        flattened = slot('kind') === 'failed';
+        const slot = (key) => ownDataField(carrier, key);
         const closed = (v) => (typeof v === 'string' && GATE_FAILURE_CODES.includes(v) ? v : undefined);
-        localCode = flattened ? (closed(slot('code')) ?? closed(slot('safetyCode'))) : closed(slot('code'));
-        name = flattened ? undefined : slot('name');
+        localCode = closed(slot('code'));
+        name = slot('name');
+        const pn = protocolErrorNameReading(carrier);
+        if (pn.state === 'unreadable')
+            throw new TypeError('protocol name unreadable');
+        protocolName = pn.state === 'named' ? pn.name : undefined;
         errorCode = slot('errorCode');
         status = slot('status');
-        retriable = refusalRetriableReading(failure);
-        text = flattened ? slot('reason') : String(failure);
+        retriable = refusalRetriableReading(carrier);
+        text = String(carrier);
     }
     catch {
         return facts('unreadable');
@@ -45,46 +131,117 @@ export function readDecisionRefusalAsk(failure) {
     if (name === 'HitlSafetyError')
         return facts('not_settled');
     const code = typeof errorCode === 'string' && errorCode.length > 0 ? errorCode : undefined;
+    if (code === RESUME_PREFLIGHT_REJECTED && (preflightSettledBitsPresent(carrier) || retriable !== true))
+        return facts('not_settled', true);
     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')
+    if (st === 404 && notPendingCauseReading(carrier) === 'ended')
         return facts('settled');
-    if (code === undefined && name === PROTOCOL_ERROR_NAMES.askDecided)
+    if (code === undefined && protocolName === PROTOCOL_ERROR_NAME.AskDecidedError)
         return facts('settled');
-    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)
+    const gateMoved = isDecideAlreadyResolvedCode(code) || isDecideParkMovedCode(code) || code === ASK_GONE_PARKED || (code === undefined && protocolName === PROTOCOL_ERROR_NAME.ApprovalStaleError);
+    if (gateMoved || st !== undefined || protocolName === PROTOCOL_ERROR_NAME.ParkedResumeStartupError)
         return facts('not_settled', gateMoved);
     return facts('not_settled', false, isAlreadyResolvedGateReason(text));
 }
 export function decisionRefusalAskReading(failure) {
     return readDecisionRefusalAsk(failure).reading;
 }
-export function classifyDecisionRefusal(err) {
-    const r = readToolApprovalRespondRefusal(err);
-    const status = r?.status;
-    if (status === undefined || !Number.isInteger(status) || status < 400 || status > 599)
+const USELESS_REFUSAL_TEXTS = new Set(['[object Object]', 'null', 'undefined', '']);
+function refusalTextOf(err) {
+    const message = typeof err === 'object' && err !== null ? guardedRead(() => err.message) : undefined;
+    if (typeof message === 'string' && message.length > 0)
+        return message;
+    if (typeof err === 'string' && err.length > 0)
+        return err;
+    let coerced;
+    try {
+        coerced = String(err);
+    }
+    catch {
         return undefined;
-    const code = r?.errorCode;
-    const errorCode = code !== undefined && DISPLAYABLE_CODE.test(code) ? code : undefined;
-    const standing = readDecisionRefusalAsk(err).reading === 'settled'
-        ? 'settled-elsewhere'
-        : status >= 500 && status !== 501
-            ? 'ambiguous'
-            : 'refused-pending';
-    const transient = TRANSIENT_STATUSES.has(status) ||
-        (typeof err === 'object' && err !== null && (refusalSaysStillPending(err) || (status === 404 && notPendingCauseReading(err) === 'other_replica')));
-    const conflict = status === 409 ? decisionConflictOf(err) : undefined;
+    }
+    return USELESS_REFUSAL_TEXTS.has(coerced) ? undefined : coerced;
+}
+function isolated(read) {
+    return guardedRead(read);
+}
+export function mintDecisionRefusalReading(err, context, attributionCarried) {
+    const { carrier } = refusalCarrierOf(err);
+    const obj = typeof carrier === 'object' && carrier !== null ? carrier : undefined;
+    const status = carrierStatus(carrier);
+    const wire = obj !== undefined ? isolated(() => readWireCodes(obj)) : undefined;
+    const errorCode = wire?.errorCode ?? carrierCode(carrier);
+    const message = isolated(() => refusalTextOf(carrier));
+    const retriable = obj !== undefined && isolated(() => refusalSaysStillPending(obj)) === true;
+    const pn = obj !== undefined ? isolated(() => protocolErrorNameReading(obj)) : undefined;
+    const protocolName = pn?.state === 'named' ? pn.name : undefined;
+    const cause = obj !== undefined ? isolated(() => refusalCauseWordOf(obj)) : undefined;
+    const field = obj !== undefined ? isolated(() => readRefusalField(obj)) : undefined;
+    const currentPending = obj !== undefined ? isolated(() => readDecideCurrentPending(obj)) : undefined;
+    const attribution = attributionCarried !== undefined ? isolated(() => denyAttributionRefusalFromError(carrier, attributionCarried)) : undefined;
+    const ask = readDecisionRefusalAsk(err);
+    const delivery = refusalDeliveryOf(err, context);
+    const standing = delivery.delivery === 'no_answer' ? undefined : ask.reading === 'settled' ? 'settled-elsewhere' : delivery.delivery === 'refused' ? 'refused-pending' : 'ambiguous';
+    const inRange = standing !== undefined && status !== undefined;
+    const transient = inRange &&
+        (TRANSIENT_STATUSES.has(status) || retriable || (status === 404 && obj !== undefined && isolated(() => notPendingCauseReading(obj)) === 'other_replica'));
+    const conflict = inRange && status === 409 && obj !== undefined ? isolated(() => decisionConflictOf(obj)) : undefined;
     return Object.freeze({
-        standing,
-        status,
+        ...(status !== undefined ? { status } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(message !== undefined ? { message } : {}),
+        ...(retriable ? { retriable: true } : {}),
+        ...(protocolName !== undefined ? { protocolName } : {}),
+        ...(cause !== undefined || field !== undefined ? { extra: Object.freeze({ ...(cause !== undefined ? { cause } : {}), ...(field !== undefined ? { field } : {}) }) } : {}),
+        ...(wire?.blockedBy !== undefined ? { blockedBy: wire.blockedBy } : {}),
+        ...(currentPending !== undefined ? { currentPending } : {}),
+        ...(attribution !== undefined && attribution !== null ? { denyAttributionRefusal: attribution } : {}),
+        ask: ask.reading,
+        ...(ask.gateMoved ? { gateMoved: true } : {}),
+        ...(ask.wordingHint ? { wordingHint: true } : {}),
+        ...(standing !== undefined ? { standing } : {}),
         ...(transient ? { transient: true } : {}),
         ...(conflict !== undefined ? { conflict } : {}),
     });
 }
+export function readDecisionRefusalReading(err, context) {
+    return mintDecisionRefusalReading(err, context);
+}
+function classifiedOf(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    try {
+        const standing = ownDataField(reading, 'standing');
+        const status = ownDataField(reading, 'status');
+        if ((standing !== 'settled-elsewhere' && standing !== 'ambiguous' && standing !== 'refused-pending') || typeof status !== 'number')
+            return undefined;
+        const code = ownDataField(reading, 'errorCode');
+        const errorCode = typeof code === 'string' && isDisplayableWireCode(code) ? code : undefined;
+        const transient = ownDataField(reading, 'transient') === true;
+        const conflict = ownDataField(reading, 'conflict');
+        return Object.freeze({
+            standing,
+            status,
+            ...(errorCode !== undefined ? { errorCode } : {}),
+            ...(transient ? { transient: true } : {}),
+            ...(typeof conflict === 'string' ? { conflict: conflict } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function classifyDecisionRefusal(err, context) {
+    if (isResolutionShaped(err)) {
+        const refusal = guardedRead(() => (ownDataField(err, 'kind') === 'unsettled' ? ownDataField(err, 'refusal') : undefined));
+        return classifiedOf(refusal);
+    }
+    return classifiedOf(mintDecisionRefusalReading(err, context));
+}
 export function liveAskPendingReading(envelope, approvalId) {
     if (typeof approvalId !== 'string' || approvalId === '')
         return 'unknown';
@@ -114,9 +271,9 @@ export function decisionRefusalClosesOut(refusal, pending) {
     }
 }
 export function undeliverableDecisionContent(facts) {
-    const code = typeof facts.errorCode === 'string' && DISPLAYABLE_CODE.test(facts.errorCode) ? ` ${facts.errorCode}` : '';
+    const code = typeof facts.errorCode === 'string' && isDisplayableWireCode(facts.errorCode) ? ` ${facts.errorCode}` : '';
     const head = `The engine refused the approval decision this client sent (HTTP ${String(facts.status)}${code}), so the call it asked about could not be answered from here and did not run`;
-    const runId = typeof facts.runId === 'string' && DISPLAYABLE_CODE.test(facts.runId) ? ` ${facts.runId}` : '';
+    const runId = typeof facts.runId === 'string' && isDisplayableWireCode(facts.runId) ? ` ${facts.runId}` : '';
     switch (facts.end) {
         case 'run-stopped':
             return `${head}; the run was stopped instead of being left waiting for the approval window to close. Update the client, or run the task in an interactive session and answer the approval there.`;

package/dist/hitl/frameRouter.d.ts

@@ -1,6 +1,7 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import type { DecideOperationObserver, HitlClientLike } from './hitlBridge.js';
-import { type RespondToolApprovalFn, type ToolApprovalFrame, type ToolApprovalFrameLaneOpts, type ToolApprovalFrameOutcome } from './toolApprovalWire.js';
+import { type RespondToolApprovalFn, type ToolApprovalFrame, type ToolApprovalFrameLaneOpts } from './toolApprovalWire.js';
+import type { ApprovalResolution } from './approvalResolution.js';
 import type { GateLedger } from './gateLedger.js';
 import type { NoAllowCause } from './noAllowCause.js';
 import { type ReplayedApprovalDisposition } from './replayedApproval.js';
@@ -31,13 +32,14 @@ export interface AskGateWireDeps {
     respondToolApproval?: RespondToolApprovalFn;
     onParkReattach?: (e: ParkReattachNotice) => void;
     approvalLane?: ToolApprovalFrameLaneOpts;
-    onToolApprovalOutcome?: (frame: ToolApprovalFrame, outcome: ToolApprovalFrameOutcome) => void | Promise<void>;
+    onToolApprovalOutcome?: (frame: ToolApprovalFrame, resolution: ApprovalResolution) => void | Promise<void>;
     onDecideOperation?: DecideOperationObserver;
     onReplayedApproval?: (frame: ToolApprovalFrame, disposition: ReplayedApprovalDisposition) => void | Promise<void>;
 }
 type GateKind = 'ask' | 'fs';
 export interface GatePark {
     gate: GateKind;
+    parkFrame: AgentEvent;
     pendingDone?: AgentEvent | undefined;
     gatedCallId?: string | undefined;
     toolName?: string | undefined;
@@ -50,6 +52,7 @@ export type FrameAction = {
 } | {
     kind: 'park';
     gate: GateKind;
+    parkFrame: AgentEvent;
     pendingDone?: AgentEvent | undefined;
     gatedCallId?: string | undefined;
     toolName?: string | undefined;

package/dist/hitl/frameRouter.js

@@ -5,6 +5,8 @@ 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 { parkHeldCallIdOf } from '../engineRowRef.js';
+import { inheritFrameBinding } from '../frameBinding.js';
 import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from './hitlHostSurface.js';
 import { liveCardHoldOf, noteEngineClosedApproval, supersedeLiveCard } from './approvalHolds.js';
 import { approvalCompleteParked } from './approvalCompleteParked.js';
@@ -69,12 +71,12 @@ function denialKindForTranscript(attribution) {
 }
 function denyStampedEnd(ev, attribution) {
     const kind = denialKindForTranscript(attribution);
-    return {
+    return inheritFrameBinding(ev, {
         ...ev,
         output: denyOutputForRender(attribution),
         structured: undefined,
         ...(kind !== undefined ? { [SEMA_DENIAL_KIND_KEY]: kind } : {}),
-    };
+    });
 }
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
@@ -149,8 +151,7 @@ function parkGateOf(result) {
     return arm === null ? null : { taskId, gate: arm, toolName };
 }
 function parkGatedCallId(src) {
-    const v = src?.toolCallId;
-    return typeof v === 'string' && v.length > 0 ? v : undefined;
+    return parkHeldCallIdOf(src);
 }
 function argsOfGatedStart(led, callId) {
     if (callId === undefined)
@@ -192,7 +193,9 @@ export function* flushHeldWithInterruptRewrite(led, evidence) {
             yield ev;
             continue;
         }
-        yield { ...ev, output: HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE };
+        yield inheritFrameBinding(ev, (gateAborted
+            ? { ...ev, output: HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE, [SEMA_DENIAL_KIND_KEY]: 'interrupted' }
+            : { ...ev, output: HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE }));
     }
 }
 const TOOL_END_ARM_ORDER = [
@@ -216,7 +219,7 @@ const TOOL_END_ARMS = [
             const startArgs = led.startArgs().get(callId);
             surfaceForCurrentSession()?.surfaceClassifierDeny(typeof ev.toolName === 'string' ? ev.toolName : 'tool', verdict, { toolCallId: callId, ...(startArgs !== undefined ? { args: startArgs } : {}) });
             hostLog('debug', `liveHitlAskWire: classifier deny verdict on ${callId} (${String(ev.toolName)}) — labeled render + notice`);
-            return { kind: 'yield', events: [{ ...ev, output: verdict.message, structured: undefined }] };
+            return { kind: 'yield', events: [inheritFrameBinding(ev, { ...ev, output: verdict.message, structured: undefined })] };
         },
     },
     {
@@ -264,7 +267,7 @@ const TOOL_END_ARMS = [
             const answered = led.answerFor(callId);
             if (answered && ev.isError !== true && ev.structured === undefined) {
                 led.dropAnswer(callId);
-                return { kind: 'yield', events: [{ ...ev, structured: answered }] };
+                return { kind: 'yield', events: [inheritFrameBinding(ev, { ...ev, structured: answered })] };
             }
             return { kind: 'yield', events: [ev] };
         },
@@ -328,14 +331,13 @@ async function routeToolApprovalFrame(ev, ctx) {
 }
 function settleLiveCardOutcome(ev, outcome, ctx, fromSubagent, gatedCallId) {
     const { led, deps } = ctx;
-    const { decision } = outcome;
     if (deps.onToolApprovalOutcome !== undefined) {
         invokeHostCallbackIsolated('liveHitlAskWire: onToolApprovalOutcome', () => deps.onToolApprovalOutcome?.(ev, outcome));
     }
-    if (decision === 'deny' && !fromSubagent) {
+    if (outcome.kind === 'decided' && outcome.decision === 'deny' && !fromSubagent) {
         const attribution = {
-            ...(outcome.denySettledBy !== undefined ? { settledBy: outcome.denySettledBy } : {}),
-            ...(outcome.denyReason !== undefined ? { reason: outcome.denyReason } : {}),
+            ...(outcome.deny?.settledBy !== undefined ? { settledBy: outcome.deny.settledBy } : {}),
+            ...(outcome.deny?.reason !== undefined ? { reason: outcome.deny.reason } : {}),
         };
         if (gatedCallId !== undefined)
             led.markDenied(gatedCallId, attribution);
@@ -400,15 +402,16 @@ function routeSuspended(ev, ctx) {
     const gatedCallId = parkGatedCallId(ev);
     const arm = parkGateArmOf(ev.gate);
     if (arm === 'ask' && ctx.taskId.current) {
-        ctx.led.noteParkGate({ fsOrShellFamily: false });
-        return { kind: 'park', gate: 'ask', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
+        ctx.led.noteParkGate({ fsOrShellFamily: false, gatedCallId });
+        return { kind: 'park', gate: 'ask', parkFrame: ev, ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
     }
     if (arm === 'fs' && ctx.taskId.current) {
         const gateToolName = ev.gate?.toolName;
-        ctx.led.noteParkGate({ fsOrShellFamily: parkFamilyEvidence(ctx.led, gateToolName, gatedCallId) });
+        ctx.led.noteParkGate({ fsOrShellFamily: parkFamilyEvidence(ctx.led, gateToolName, gatedCallId), gatedCallId });
         return {
             kind: 'park',
             gate: 'fs',
+            parkFrame: ev,
             ...(gatedCallId !== undefined ? { gatedCallId } : {}),
             ...(typeof gateToolName === 'string' && gateToolName !== '' ? { toolName: gateToolName } : {}),
         };
@@ -421,10 +424,11 @@ function routeDone(ev, ctx) {
     const park = parkGateOf(ev.result);
     if (park !== null) {
         ctx.taskId.current = ctx.taskId.current ?? park.taskId;
-        led.noteParkGate({ fsOrShellFamily: park.gate === 'fs' && parkFamilyEvidence(led, park.toolName, gatedCallId) });
+        led.noteParkGate({ fsOrShellFamily: park.gate === 'fs' && parkFamilyEvidence(led, park.toolName, gatedCallId), gatedCallId });
         return {
             kind: 'park',
             gate: park.gate,
+            parkFrame: ev,
             pendingDone: ev,
             ...(gatedCallId !== undefined ? { gatedCallId } : {}),
             ...(park.toolName !== undefined && park.toolName !== '' ? { toolName: park.toolName } : {}),
@@ -434,7 +438,7 @@ function routeDone(ev, ctx) {
     const r = ev.result;
     const realTaskId = ctx.taskId.current;
     if (realTaskId && r && r.taskId === r.sessionId && r.taskId !== realTaskId) {
-        events.push({ ...ev, result: { ...ev.result, taskId: realTaskId } });
+        events.push(inheritFrameBinding(ev, { ...ev, result: { ...ev.result, taskId: realTaskId } }));
     }
     else {
         events.push(ev);

package/dist/hitl/gateLedger.d.ts

@@ -14,6 +14,7 @@ export interface AskAnsweredOutput {
     }>;
 }
 export declare function durableSeqOf(ev: object): string | undefined;
+export declare const BODY_SEQ_OTHER_AXIS_EVENTS: readonly string[];
 export declare function hasLedgerPositionKey(ev: object): boolean;
 export declare const PREAMBLE_APPROVALS_MAX_ENTRIES = 4096;
 export interface GateLedger {
@@ -52,6 +53,7 @@ export interface GateLedger {
     isFsOrShellGatedCall(callId: string): boolean;
     noteParkGate(evidence: {
         fsOrShellFamily: boolean;
+        gatedCallId?: string | undefined;
     }): void;
     hasBatchPark(): boolean;
     rememberAnswer(callId: string, answered: AskAnsweredOutput): void;

package/dist/hitl/gateLedger.js

@@ -1,13 +1,21 @@
+import { parkedToolEndRoleOf } from '../engineRowRef.js';
+import { inheritFrameBinding } from '../frameBinding.js';
 export const SEMA_COLLATERAL_ABORT_KEY = '_sema_collateral_abort';
 export const SEMA_DENIAL_KIND_KEY = '_sema_denial_kind';
 export function durableSeqOf(ev) {
-    const rawSeq = ev.id ?? ev.seq;
+    const rec = ev;
+    const id = rec.id;
+    const rawSeq = id ?? (seqIsAnotherAxis(rec.type) ? undefined : rec.seq);
     if (typeof rawSeq === 'string' && rawSeq.length > 0)
         return rawSeq;
     if (typeof rawSeq === 'number' && Number.isFinite(rawSeq))
         return String(rawSeq);
     return undefined;
 }
+export const BODY_SEQ_OTHER_AXIS_EVENTS = Object.freeze(['task_progress', 'task_notification', 'task_started']);
+function seqIsAnotherAxis(type) {
+    return typeof type === 'string' && BODY_SEQ_OTHER_AXIS_EVENTS.includes(type);
+}
 export function hasLedgerPositionKey(ev) {
     const { id, seq } = ev;
     return (id !== undefined && id !== null) || (seq !== undefined && seq !== null);
@@ -27,8 +35,8 @@ export function createGateLedger() {
     const startedCalls = new Set();
     const endedCalls = new Set();
     const heldAskEnds = new Map();
-    const gatedStartArgsByCall = new Map();
     const startArgsByCall = new Map();
+    const gatedStartCalls = new Set();
     const deniedCalls = new Set();
     const denyAttributionByCall = new Map();
     const pendingFsCalls = [];
@@ -37,6 +45,7 @@ export function createGateLedger() {
     let alreadyResolvedKey;
     let alreadyResolvedStreak = 0;
     let fsOrShellFamilyGate = false;
+    let batchParkSubject;
     const droppedFromBatch = new Set();
     let batchParkCount = 0;
     let heldSinceLastPark = false;
@@ -45,6 +54,8 @@ export function createGateLedger() {
     const resolveGateSubjects = () => {
         if (batchParkCount !== 1)
             return undefined;
+        if (batchParkSubject !== undefined)
+            return new Set([batchParkSubject]);
         if (!fsOrShellFamilyGate)
             return undefined;
         for (const id of heldAskEnds.keys()) {
@@ -78,8 +89,16 @@ export function createGateLedger() {
         }
         return n === 1;
     };
+    const bystanderUnderIdentity = (ev, subject) => {
+        const parent = ev.parentToolCallId;
+        if (typeof parent === 'string' && parent !== '')
+            return false;
+        const own = ev.gatedCallId;
+        return !(typeof own === 'string' && own !== '' && own !== subject);
+    };
     const retireBatchState = () => {
         fsOrShellFamilyGate = false;
+        batchParkSubject = undefined;
         droppedFromBatch.clear();
         batchParkCount = 0;
         heldSinceLastPark = false;
@@ -101,8 +120,8 @@ export function createGateLedger() {
         forgetRunScopedState() {
             seq = undefined;
             startedCalls.clear();
-            gatedStartArgsByCall.clear();
             startArgsByCall.clear();
+            gatedStartCalls.clear();
         },
         notePreambleApproval(approvalId) {
             if (typeof approvalId !== 'string' || approvalId === '')
@@ -144,26 +163,41 @@ export function createGateLedger() {
             return true;
         },
         noteGatedStart(callId, ev) {
-            gatedStartArgsByCall.set(callId, ev.args);
+            if (!startArgsByCall.has(callId))
+                startArgsByCall.set(callId, ev.args);
+            gatedStartCalls.add(callId);
         },
         gatedStartArgs() {
-            return gatedStartArgsByCall;
+            const out = new Map();
+            for (const id of gatedStartCalls)
+                if (startArgsByCall.has(id))
+                    out.set(id, startArgsByCall.get(id));
+            return out;
         },
         noteStart(callId, ev) {
+            if (gatedStartCalls.has(callId))
+                return;
             startArgsByCall.delete(callId);
             startArgsByCall.set(callId, ev.args);
-            while (startArgsByCall.size > START_ARGS_MAX_ENTRIES) {
-                const oldest = startArgsByCall.keys().next();
-                if (oldest.done === true)
+            while (startArgsByCall.size - gatedStartCalls.size > START_ARGS_MAX_ENTRIES) {
+                let victim;
+                for (const id of startArgsByCall.keys()) {
+                    if (!gatedStartCalls.has(id)) {
+                        victim = id;
+                        break;
+                    }
+                }
+                if (victim === undefined)
                     break;
-                startArgsByCall.delete(oldest.value);
+                startArgsByCall.delete(victim);
             }
         },
         startArgs() {
             return startArgsByCall;
         },
         dropStartArgs(callId) {
-            startArgsByCall.delete(callId);
+            if (!gatedStartCalls.has(callId))
+                startArgsByCall.delete(callId);
         },
         isEnded(callId) {
             return endedCalls.has(callId);
@@ -195,10 +229,12 @@ export function createGateLedger() {
         },
         *flushHeld() {
             const subjects = resolveGateSubjects();
+            const identity = subjects !== undefined ? batchParkSubject : undefined;
             for (const [callId, ev] of heldAskEnds) {
-                endedCalls.add(callId);
-                yield subjects !== undefined && !subjects.has(callId)
-                    ? { ...ev, [SEMA_COLLATERAL_ABORT_KEY]: true }
+                if (parkedToolEndRoleOf(ev) !== 'held')
+                    endedCalls.add(callId);
+                yield subjects !== undefined && !subjects.has(callId) && (identity === undefined || bystanderUnderIdentity(ev, identity))
+                    ? inheritFrameBinding(ev, { ...ev, [SEMA_COLLATERAL_ABORT_KEY]: true })
                     : ev;
             }
             heldAskEnds.clear();
@@ -260,6 +296,7 @@ export function createGateLedger() {
                 return;
             batchParkCount += 1;
             fsOrShellFamilyGate = evidence.fsOrShellFamily;
+            batchParkSubject = typeof evidence.gatedCallId === 'string' && evidence.gatedCallId !== '' ? evidence.gatedCallId : undefined;
             heldSinceLastPark = false;
         },
         hasBatchPark() {

package/dist/hitl/hitlBridge.d.ts

@@ -48,7 +48,6 @@ export type PlanReviewModeAfter = (typeof PLAN_REVIEW_MODE_AFTER_WORDS)[number];
 export declare function isPlanReviewModeAfter(v: string | undefined): v is PlanReviewModeAfter;
 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";
 export declare const NO_QUESTION_OVERLAY_REASON = "no question overlay mounted (print/non-REPL mode)";
@@ -61,7 +60,7 @@ export interface HitlDecideDenyOutcome {
 }
 export declare class HitlSafetyError extends Error {
     readonly code: HitlSafetyCode;
-    constructor(message: string, code: HitlSafetyCode);
+    constructor(message: string, code: HitlSafetyCode, options?: ErrorOptions);
 }
 export declare function hitlSafetyCodeOf(e: unknown): HitlSafetyCode | undefined;
 export type GateCurrentPending = Readonly<NonNullable<ApprovalStaleError['currentPending']>>;