@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/hitl/approvalCompleteParked.js

@@ -0,0 +1,14 @@
+function ownData(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && 'value' in d ? d.value : undefined;
+}
+export function approvalCompleteParked(frame) {
+    try {
+        if (frame === null || typeof frame !== 'object')
+            return false;
+        return ownData(frame, 'outcome') === 'expired' && ownData(frame, 'parked') === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hitl/approvalEndingCause.d.ts

@@ -0,0 +1,5 @@
+import type { ApprovalSettleCause, AskRowEndingCause } from '@sema-agent/sdk';
+export declare const ASK_ROW_ENDING_CAUSE_WORDS: readonly ["routing_failure_fail_closed", "run_cancelled", "run_exited", "batch_aborted", "batch_sibling_withdrawn", "batch_bound_elsewhere", "adhoc_leg_no_durable_domain", "orphan_ttl_exceeded", "crashed_before_park", "shutdown_before_park"];
+export declare function askRowEndingCauseFor(state: 'VOID' | 'DENIED' | undefined, word: unknown): AskRowEndingCause | undefined;
+export declare function approvalCompleteCauseOf(frame: unknown): ApprovalSettleCause | undefined;
+export declare function notPendingCauseSaysEnded(err: object): boolean;

package/dist/hitl/approvalEndingCause.js

@@ -0,0 +1,61 @@
+import { ASK_GONE_DENIED_WORD } from '../engineErrorCodes.js';
+import { SDK_ASK_ROW_ENDING_CAUSES } from '../generated/sdkFactTables.js';
+export const ASK_ROW_ENDING_CAUSE_WORDS = SDK_ASK_ROW_ENDING_CAUSES;
+const _askRowCausePin = true;
+void _askRowCausePin;
+const DENIED_GROUP_WORD = ASK_GONE_DENIED_WORD;
+const WAIT_CLASS_SETTLE_CAUSE_WORDS = Object.freeze({
+    ttl_expired: true,
+    broadcast_lost: true,
+    stream_disconnected: true,
+    undeliverable: true,
+});
+function isAskRowEndingCause(v) {
+    return typeof v === 'string' && ASK_ROW_ENDING_CAUSE_WORDS.includes(v);
+}
+function isApprovalSettleCause(v) {
+    return isAskRowEndingCause(v) || (typeof v === 'string' && Object.hasOwn(WAIT_CLASS_SETTLE_CAUSE_WORDS, v));
+}
+export function askRowEndingCauseFor(state, word) {
+    if (!isAskRowEndingCause(word))
+        return undefined;
+    if (state === 'DENIED')
+        return word === DENIED_GROUP_WORD ? word : undefined;
+    if (state === 'VOID')
+        return word !== DENIED_GROUP_WORD ? word : undefined;
+    return undefined;
+}
+export function approvalCompleteCauseOf(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return undefined;
+        const typeSlot = Object.getOwnPropertyDescriptor(frame, 'type');
+        if (typeSlot === undefined || !Object.hasOwn(typeSlot, 'value') || typeSlot.value !== 'tool_approval_complete')
+            return undefined;
+        const causeSlot = Object.getOwnPropertyDescriptor(frame, 'cause');
+        if (causeSlot === undefined || !Object.hasOwn(causeSlot, 'value'))
+            return undefined;
+        const word = causeSlot.value;
+        return isApprovalSettleCause(word) ? word : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const LEGACY_NOT_PENDING_ENDED_WORDS = new Set(['voided', 'denied']);
+export function notPendingCauseSaysEnded(err) {
+    try {
+        const extraSlot = Object.getOwnPropertyDescriptor(err, 'extra');
+        const extra = extraSlot !== undefined && Object.hasOwn(extraSlot, 'value') ? extraSlot.value : undefined;
+        if (typeof extra !== 'object' || extra === null || Array.isArray(extra))
+            return false;
+        const causeSlot = Object.getOwnPropertyDescriptor(extra, 'cause');
+        if (causeSlot === undefined || !Object.hasOwn(causeSlot, 'value'))
+            return false;
+        const word = causeSlot.value;
+        return isAskRowEndingCause(word) || (typeof word === 'string' && LEGACY_NOT_PENDING_ENDED_WORDS.has(word));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hitl/approvalHolds.d.ts

@@ -1,4 +1,4 @@
-import type { FsApprovalOutcome, ToolApprovalFrameOutcome } from './toolApprovalWire.js';
+import type { ApprovalHolderIdentity, FsApprovalOutcome, ToolApprovalFrameOutcome } from './toolApprovalWire.js';
 export interface DurableDecisionHold {
     readonly lane: 'durable';
     readonly outcome: Promise<FsApprovalOutcome>;
@@ -9,6 +9,7 @@ export interface DurableDecisionHold {
 }
 export interface LiveCardHold {
     readonly lane: 'live';
+    readonly identity: LiveCardIdentity;
     readonly outcome: Promise<ToolApprovalFrameOutcome>;
     phase: 'card' | 'respond';
     superseded?: {
@@ -19,6 +20,15 @@ export interface LiveCardHold {
     trailing?: Promise<void>;
 }
 export type ApprovalHold = DurableDecisionHold | LiveCardHold;
+export interface LiveCardIdentity {
+    readonly approvalId: string;
+    readonly toolCallId?: string;
+    readonly taskId?: string;
+    readonly sessionId?: string;
+}
+export declare function liveCardHoldFor(who: ApprovalHolderIdentity): LiveCardHold | undefined;
+export declare function liveCardAnsweredHow(o: ToolApprovalFrameOutcome): 'answered' | 'interrupted' | undefined;
+export declare function awaitLiveCardHolder(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ToolApprovalFrameOutcome | undefined>;
 export interface ApprovalDecisionHoldTable {
     readonly inFlight: Map<string, ApprovalHold>;
     readonly settled: Map<string, DurableSettledHold>;
@@ -31,6 +41,6 @@ export interface DurableSettledHold {
 }
 export declare const approvalDecisionHolds: ApprovalDecisionHoldTable;
 export declare function liveCardHoldOf(key: string): LiveCardHold | undefined;
-export declare function holdLiveCard(key: string, callerSignal: AbortSignal | undefined, present: (hold: LiveCardHold) => Promise<ToolApprovalFrameOutcome>): Promise<ToolApprovalFrameOutcome>;
+export declare function holdLiveCard(identity: LiveCardIdentity, callerSignal: AbortSignal | undefined, present: (hold: LiveCardHold) => Promise<ToolApprovalFrameOutcome>): Promise<ToolApprovalFrameOutcome>;
 export declare function joinLiveCard(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ToolApprovalFrameOutcome>;
 export declare function supersedeLiveCard(key: string, parked: boolean): boolean;

package/dist/hitl/approvalHolds.js

@@ -1,10 +1,61 @@
 import { hostLog } from '../host.js';
+import { liveFrameCallKey } from './gateIdentity.js';
+import { approvalResolutionOf } from './approvalResolution.js';
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+export function liveCardHoldFor(who) {
+    if (nonEmpty(who.approvalId))
+        return liveCardHoldOf(liveFrameCallKey(who.approvalId));
+    if (!nonEmpty(who.taskId) || !nonEmpty(who.toolCallId))
+        return undefined;
+    for (const h of approvalDecisionHolds.inFlight.values()) {
+        if (h.lane !== 'live' || h.phase !== 'card')
+            continue;
+        const id = h.identity;
+        if (id.taskId !== who.taskId || id.toolCallId !== who.toolCallId)
+            continue;
+        if (nonEmpty(who.sessionId) && nonEmpty(id.sessionId) && id.sessionId !== who.sessionId)
+            continue;
+        return h;
+    }
+    return undefined;
+}
+function liveCardSettledQuestion(hold, o) {
+    const r = approvalResolutionOf(o);
+    if (answeredHowOf(r) !== undefined)
+        return true;
+    if (r.kind === 'unsettled')
+        return false;
+    return hold.superseded !== undefined && !hold.superseded.parked;
+}
+export function liveCardAnsweredHow(o) {
+    return answeredHowOf(approvalResolutionOf(o));
+}
+function answeredHowOf(r) {
+    if (r.kind === 'decided')
+        return 'answered';
+    return r.kind === 'unsettled' && r.cause === 'interrupted' ? 'interrupted' : undefined;
+}
+export async function awaitLiveCardHolder(hold, signal) {
+    const unsubscribe = followCallerSignal(signal, hold.interrupt);
+    let o;
+    try {
+        o = await hold.outcome;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        unsubscribe();
+    }
+    return liveCardSettledQuestion(hold, o) ? { ...o, joinedInFlight: true } : undefined;
+}
 export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), clock: 0 };
 export function liveCardHoldOf(key) {
     const h = approvalDecisionHolds.inFlight.get(key);
     return h !== undefined && h.lane === 'live' ? h : undefined;
 }
-export function holdLiveCard(key, callerSignal, present) {
+export function holdLiveCard(identity, callerSignal, present) {
+    const key = liveFrameCallKey(identity.approvalId);
     const h = approvalDecisionHolds;
     const cut = new AbortController();
     let settled = false;
@@ -19,7 +70,7 @@ export function holdLiveCard(key, callerSignal, present) {
         resolveOutcome = resolve;
         rejectOutcome = reject;
     });
-    const hold = { lane: 'live', outcome, phase: 'card', cardSignal: cut.signal, interrupt };
+    const hold = { lane: 'live', identity: Object.freeze({ ...identity }), outcome, phase: 'card', cardSignal: cut.signal, interrupt };
     h.inFlight.set(key, hold);
     const release = () => {
         if (h.inFlight.get(key) === hold)

package/dist/hitl/approvalsFeed.js

@@ -1,7 +1,7 @@
 import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
 import { readLivePendingRows } from './livePendingAsk.js';
-import { isInStreamDrainingEnd } from '../wireErrorTriage.js';
+import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
 const MAX_CONSECUTIVE_POLL_ESCAPES = 5;
 function readDurablePendingRows(raw) {
     if (!Array.isArray(raw))
@@ -365,7 +365,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 .then(() => scheduleReconcile());
         }, reconcileDelayMs));
     }
-    function scheduleStreamRetry() {
+    function scheduleStreamRetry(afterMs = streamRetryMs) {
         if (stopped || ac.signal.aborted || streamRetryMs <= 0)
             return;
         if (!client.approvals.stream)
@@ -378,9 +378,9 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 return;
             hostLog('debug', 'approvalsFeed: retrying push leg (降级是暂时的,服务端升级后不该还要重启客户端)');
             void runStream();
-        }, streamRetryMs));
+        }, afterMs));
     }
-    function degradeToPoll(why, real = true) {
+    function degradeToPoll(why, real = true, retryAfterMs) {
         if (stopped)
             return;
         if (real)
@@ -390,8 +390,9 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         }
         mode = 'poll';
         schedulePoll();
-        scheduleStreamRetry();
+        scheduleStreamRetry(retryAfterMs);
     }
+    const drains = createStreamDrainingLegs();
     async function runStream() {
         const stream = client.approvals.stream;
         if (!stream) {
@@ -402,6 +403,10 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             for await (const ev of stream.call(client.approvals, { signal: ac.signal })) {
                 if (stopped || ac.signal.aborted)
                     return;
+                if (drains.see(ev)) {
+                    hostLog('debug', 'approvalsFeed: push leg received the drain end frame — the engine is going down; this leg ends with it and reopens on the draining ladder');
+                    continue;
+                }
                 if (mode !== 'push') {
                     mode = 'push';
                     if (pollTimer !== undefined) {
@@ -416,17 +421,24 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                     stats.heartbeats++;
                     continue;
                 }
-                if (isInStreamDrainingEnd(ev)) {
-                    hostLog('debug', 'approvalsFeed: push leg received the drain end frame — the engine is going down; the stream reconnects and re-syncs on its own');
-                    continue;
-                }
                 stats.pushEvents++;
                 await take('push');
             }
-            if (!stopped && !ac.signal.aborted)
-                degradeToPoll('stream ended without progress');
+            if (stopped || ac.signal.aborted)
+                return;
+            const drained = drains.legEnded('returned');
+            if (drained !== undefined) {
+                const decision = drained;
+                if ('reconnectAfterMs' in decision)
+                    degradeToPoll(`engine draining — push leg closed; reopening in ${decision.reconnectAfterMs}ms`, false, decision.reconnectAfterMs);
+                else
+                    degradeToPoll(`engine draining — reconnect attempts exhausted (${decision.giveUp})`);
+                return;
+            }
+            degradeToPoll('stream ended without progress');
         }
         catch (e) {
+            drains.legEnded('threw');
             if (stopped || ac.signal.aborted)
                 return;
             degradeToPoll(String(e));

package/dist/hitl/askGateWire.d.ts

@@ -8,9 +8,10 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
+export { GATE_FAILURE_CODES } from './hitlBridge.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {
     signal?: AbortSignal;
     taskId?: string;

package/dist/hitl/askGateWire.js

@@ -1,12 +1,16 @@
 import { createGateLedger } from './gateLedger.js';
 import { flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.js';
 import { resolvePark, nextHopBudget, stalledTerminal, MAX_GATE_HOPS } from './parkResolver.js';
+import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
+import { abortableSleep } from '../abortableSleep.js';
+import { hostLog } from '../host.js';
 export { HITL_REJECT_MESSAGE, ENGINE_ABORT_TOOL_RESULT } from './frameRouter.js';
 export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { GATE_FAILURE_CODES } from './hitlBridge.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };
@@ -24,9 +28,12 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     let lastResolvedGatedCallId;
     let lastRoundDecided = false;
     let unverifiableParks = 0;
+    const drains = createStreamDrainingLegs();
     while (true) {
         let park = null;
         for await (const ev of stream) {
+            if (drains.see(ev))
+                continue;
             const answering = led.answeringLiveCards();
             if (answering.length > 0)
                 await Promise.all(answering);
@@ -57,6 +64,24 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             break;
         }
         if (!park) {
+            const drained = drains.legEnded('returned');
+            if (drained !== undefined) {
+                const reopenAfterMs = 'reconnectAfterMs' in drained ? drained.reconnectAfterMs : undefined;
+                if (reopenAfterMs !== undefined && taskId.current !== undefined && !opts?.signal?.aborted) {
+                    hostLog('debug', `liveHitlAskWire: runs.events(${taskId.current}) ended on the drain end frame — the engine is going down; reopening in ${reopenAfterMs}ms`);
+                    await abortableSleep(reopenAfterMs, opts?.signal ?? new AbortController().signal);
+                    if (!opts?.signal?.aborted) {
+                        const seq = led.lastSeq();
+                        led.beginStreamSegment();
+                        stream = deps.runsEvents(taskId.current, {
+                            ...(seq !== undefined ? { lastEventId: seq } : {}),
+                            ...(opts?.signal ? { signal: opts.signal } : {}),
+                        });
+                        continue;
+                    }
+                }
+                hostLog('debug', `liveHitlAskWire: runs.events ended on the drain end frame and is not reopened (${'giveUp' in drained ? drained.giveUp : taskId.current === undefined ? 'no run handle' : 'aborted'}) — ending this leg like a dropped stream`);
+            }
             yield* flushHeldWithInterruptRewrite(led, { signal: opts?.signal });
             return;
         }

package/dist/hitl/automaticAnswerVerdict.js

@@ -1,7 +1,7 @@
 import { CORE_MODE_ARBITRATION, CORE_MODE_RELEASE_REASONS } from '../generated/engineFactTables.js';
 import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from '../generated/engineAskFaceTables.js';
 import { mandatedApprovalDetail } from '../gateVocabulary.js';
-import { readOwnNonEmptyString } from '../ownKey.js';
+import { readAskOrigin, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPairState } from './askClassPair.js';
 import { approvalAllowRuleShadowed } from './allowRuleShadow.js';
 import { approvalIsMandated, readApprovalMandate } from './toolApprovalWire.js';
@@ -102,7 +102,7 @@ export function automaticAnswerVerdict(card, lane, facts) {
         if (typeof card !== 'object' || card === null)
             return UNKNOWN.card_unreadable;
         const face = lane === 'mode_posture' ? askFaceOfCard(card) : undefined;
-        const origin = readOwnNonEmptyString(evidenceView(card, 'origin'), 'origin');
+        const origin = readAskOrigin(evidenceView(card, 'origin'));
         if (origin !== undefined && Object.hasOwn(ORIGIN_IMPLIES_CLASS, origin)) {
             const cls = ORIGIN_IMPLIES_CLASS[origin];
             if (classBlocks(lane, cls, face))

package/dist/hitl/crashConverged.js

@@ -3,6 +3,8 @@ const CRASH_CONVERGED_CAUSE_WORDS = Object.freeze({
     shutdown_before_park: true,
 });
 export const isCrashConvergedCause = (v) => typeof v === 'string' && Object.hasOwn(CRASH_CONVERGED_CAUSE_WORDS, v);
+const _crashConvergedCausePin = true;
+void _crashConvergedCausePin;
 const isString = (v) => typeof v === 'string';
 const isNumber = (v) => typeof v === 'number';
 const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;

package/dist/hitl/decisionConflict.d.ts

@@ -0,0 +1,3 @@
+export type DecisionRefusalConflict = 'binding_mismatch' | 'row_integrity' | 'format_version' | 'answer_invalid';
+export declare function decisionConflictOf(err: unknown): DecisionRefusalConflict | undefined;
+export declare const DECISION_ANSWER_INVALID_CONTENT = "The engine rejected the answer itself because it does not fit the question that was asked \u00B7 Nothing was decided and the question is still waiting \u00B7 Correct the answer and send it again";

package/dist/hitl/decisionConflict.js

@@ -0,0 +1,43 @@
+import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
+import { readRefusalField } from '../wireFailureShape.js';
+const BINDING_SEAT_FIELDS = new Set(['boundCallId', 'boundInputHash']);
+const ANSWER_FIELD = 'answer';
+const BINDING_MISMATCH_ERROR_NAME = 'ApprovalBindingMismatchError';
+export function decisionConflictOf(err) {
+    if (typeof err !== 'object' || err === null)
+        return undefined;
+    let code;
+    let name;
+    try {
+        code = err.errorCode;
+    }
+    catch {
+        code = undefined;
+    }
+    try {
+        name = err.name;
+    }
+    catch {
+        name = undefined;
+    }
+    if (code === CHECKPOINT_UNSUPPORTED_VERSION)
+        return 'format_version';
+    const bindingFamily = code === APPROVAL_BINDING_MISMATCH || (code === undefined && name === BINDING_MISMATCH_ERROR_NAME);
+    if (!bindingFamily && code !== RESUME_OUTCOME_INVALID)
+        return undefined;
+    let field;
+    try {
+        field = readRefusalField(err);
+    }
+    catch {
+        field = undefined;
+    }
+    if (code === RESUME_OUTCOME_INVALID)
+        return field === ANSWER_FIELD ? 'answer_invalid' : undefined;
+    if (field === ANSWER_FIELD)
+        return 'answer_invalid';
+    if (field === undefined)
+        return 'row_integrity';
+    return BINDING_SEAT_FIELDS.has(field) ? 'binding_mismatch' : undefined;
+}
+export const DECISION_ANSWER_INVALID_CONTENT = 'The engine rejected the answer itself because it does not fit the question that was asked · Nothing was decided and the question is still waiting · Correct the answer and send it again';

package/dist/hitl/decisionRefusal.d.ts

@@ -1,9 +1,13 @@
+import { type DecisionRefusalConflict } from './decisionConflict.js';
 export type DecisionRefusalStanding = 'settled-elsewhere' | 'ambiguous' | 'refused-pending';
+export type { DecisionRefusalConflict } from './decisionConflict.js';
+export declare function decisionRefusalSaysAskGone(err: unknown): boolean;
 export interface DecisionRefusalClassified {
     readonly standing: DecisionRefusalStanding;
     readonly status: number;
     readonly errorCode?: string;
     readonly transient?: true;
+    readonly conflict?: DecisionRefusalConflict;
 }
 export declare function classifyDecisionRefusal(err: unknown): DecisionRefusalClassified | undefined;
 export type LiveAskPendingReading = 'pending' | 'not_pending' | 'unknown';

package/dist/hitl/decisionRefusal.js

@@ -1,9 +1,27 @@
 import { refusalSaysStillPending } from '../engineErrorCodes.js';
+import { notPendingCauseSaysEnded } from './approvalEndingCause.js';
+import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { readToolApprovalRespondRefusal } from './toolApprovalWire.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 decisionRefusalSaysAskGone(err) {
+    try {
+        if (typeof err === 'object' && err !== null && 'code' in err) {
+            const code = err.code;
+            if (code === 'no_pending')
+                return true;
+        }
+        const c = classifyDecisionRefusal(err);
+        if (c?.standing !== 'settled-elsewhere')
+            return false;
+        return c.status !== 404 || (typeof err === 'object' && err !== null && notPendingCauseSaysEnded(err));
+    }
+    catch {
+        return false;
+    }
+}
 export function classifyDecisionRefusal(err) {
     const r = readToolApprovalRespondRefusal(err);
     const status = r?.status;
@@ -17,7 +35,14 @@ export function classifyDecisionRefusal(err) {
             ? 'ambiguous'
             : 'refused-pending';
     const transient = TRANSIENT_STATUSES.has(status) || (typeof err === 'object' && err !== null && refusalSaysStillPending(err));
-    return Object.freeze({ standing, status, ...(errorCode !== undefined ? { errorCode } : {}), ...(transient ? { transient: true } : {}) });
+    const conflict = status === 409 ? decisionConflictOf(err) : undefined;
+    return Object.freeze({
+        standing,
+        status,
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(transient ? { transient: true } : {}),
+        ...(conflict !== undefined ? { conflict } : {}),
+    });
 }
 export function liveAskPendingReading(envelope, approvalId) {
     if (typeof approvalId !== 'string' || approvalId === '')

package/dist/hitl/frameRouter.js

@@ -1,13 +1,15 @@
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { isToolApprovalGate, toolNameIsFsWrite, toolNameIsShellExec, isToolApprovalFrame, isFromSubagent, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
 import { classifierDenyFromToolEnd } from '../classifierVerdictWire.js';
 import { GATE_PARKED_ERROR_CODE } from '../engineErrorCodes.js';
 import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateToolName } from '../runTerminal.js';
 import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from './hitlHostSurface.js';
-import { liveCardHoldOf, supersedeLiveCard } from './approvalHolds.js';
+import { liveCardAnsweredHow, liveCardHoldOf, supersedeLiveCard } from './approvalHolds.js';
+import { approvalCompleteParked } from './approvalCompleteParked.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { SEMA_DENIAL_KIND_KEY, hasLedgerPositionKey } from './gateLedger.js';
-import { replayedApprovalDisposition } from './replayedApproval.js';
+import { replayedApprovalDisposition, settledApprovalDisposition } from './replayedApproval.js';
 import { settleWithinDeadline } from '../abortableSleep.js';
 import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
 import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
@@ -266,48 +268,34 @@ const TOOL_END_ARMS = [
             '改顺序必须同批改 TOOL_END_ARM_ORDER 并说明为什么新顺序仍然对。');
     }
 }
-function completeFrameParked(ev) {
-    try {
-        const d = Object.getOwnPropertyDescriptor(ev, 'parked');
-        return d !== undefined && 'value' in d && d.value === true;
-    }
-    catch {
-        return false;
-    }
-}
 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), completeFrameParked(ev))) {
+        if (typeof id === 'string' && id !== '' && supersedeLiveCard(liveFrameCallKey(id), approvalCompleteParked(ev))) {
             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' };
     }
-    if (hasLedgerPositionKey(ev) && !led.preambleApprovals().has(ev.approvalId)) {
-        const disposition = await judgeLedgerApprovalFrame(ev, ctx);
+    const settledHere = settledApprovalDisposition(ev, led.settledApprovals());
+    if (settledHere !== undefined || (hasLedgerPositionKey(ev) && !led.preambleApprovals().has(ev.approvalId))) {
+        const disposition = settledHere ?? (await judgeLedgerApprovalFrame(ev, ctx));
         if (disposition.kind !== 'live') {
-            hostLog('debug', `liveHitlAskWire: tool_approval frame ${ev.approvalId} read back from the run event log is ${disposition.kind}` +
-                `${disposition.kind === 'unknown' ? ` (${disposition.why})` : disposition.cause !== undefined ? ` (${disposition.cause})` : ''}` +
-                ' — not raised as a question, no decision sent');
+            hostLog('debug', disposition.kind === 'decided' && disposition.settled !== undefined
+                ? `liveHitlAskWire: tool_approval frame ${ev.approvalId} repeats a question already settled on this bridge (${disposition.settled}) — not raised again, no decision sent`
+                : `liveHitlAskWire: tool_approval frame ${ev.approvalId} read back from the run event log is ${disposition.kind}` +
+                    `${disposition.kind === 'unknown' ? ` (${disposition.why})` : disposition.cause !== undefined ? ` (${disposition.cause})` : ''}` +
+                    ' — not raised as a question, no decision sent');
             if (disposition.kind === 'unknown' && ctx.signal?.aborted !== true)
                 surfaceReplayedApprovalListUnreadable();
             if (deps.onReplayedApproval !== undefined) {
-                try {
-                    const out = deps.onReplayedApproval(ev, disposition);
-                    if (out && typeof out.then === 'function') {
-                        void Promise.resolve(out).catch((e) => {
-                            hostLog('debug', `liveHitlAskWire: onReplayedApproval rejected: ${String(e).slice(0, 160)}`);
-                        });
-                    }
-                }
-                catch (e) {
-                    hostLog('debug', `liveHitlAskWire: onReplayedApproval threw: ${String(e).slice(0, 160)}`);
-                }
+                invokeHostCallbackIsolated('liveHitlAskWire: onReplayedApproval', () => deps.onReplayedApproval?.(ev, disposition));
             }
             return { kind: 'skip' };
         }
@@ -317,29 +305,24 @@ async function routeToolApprovalFrame(ev, ctx) {
     const frameCallId = !fromSubagent && typeof ev.toolCallId === 'string' && ev.toolCallId !== '' ? ev.toolCallId : undefined;
     const gatedCallId = fromSubagent ? undefined : frameCallId ?? led.lastPendingFsCall();
     const argsCallId = frameCallId === undefined ? gatedCallId : typeof ev.toolName === 'string' && toolNameIsFsWrite(ev.toolName) ? frameCallId : undefined;
-    const launched = surfaceToolApprovalFrameAndRespond(ev, deps.respondToolApproval, argsOfGatedStart(led, argsCallId), ctx.signal, deps.approvalLane);
+    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, outcome, ctx, fromSubagent, gatedCallId), (e) => {
+    const handled = launched.then((outcome) => settleLiveCardOutcome(ev, approvalIdAtLaunch, 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, outcome, ctx, fromSubagent, gatedCallId) {
+function settleLiveCardOutcome(ev, approvalId, 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) {
-        try {
-            const out = deps.onToolApprovalOutcome(ev, outcome);
-            if (out && typeof out.then === 'function') {
-                void Promise.resolve(out).catch((e) => {
-                    hostLog('debug', `liveHitlAskWire: onToolApprovalOutcome rejected: ${String(e).slice(0, 160)}`);
-                });
-            }
-        }
-        catch (e) {
-            hostLog('debug', `liveHitlAskWire: onToolApprovalOutcome threw: ${String(e).slice(0, 160)}`);
-        }
+        invokeHostCallbackIsolated('liveHitlAskWire: onToolApprovalOutcome', () => deps.onToolApprovalOutcome?.(ev, outcome));
     }
     if (decision === 'deny' && !fromSubagent) {
         const attribution = {
@@ -374,7 +357,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 });
+    return replayedApprovalDisposition(ev, { preamble: ctx.led.preambleApprovals(), approvals, settled: ctx.led.settledApprovals() });
 }
 function routeToolStart(ev, callId, led) {
     led.noteStart(callId, ev);

package/dist/hitl/gateLedger.d.ts

@@ -16,6 +16,9 @@ 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;
@@ -23,6 +26,8 @@ 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>;