@sema-agent/client-core 0.94.0 → 0.96.0

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/askParkRowRouting.js

@@ -50,7 +50,7 @@ export function askParkRowArm(row) {
     const rowHasToolName = typeof row.toolName === 'string' && row.toolName.trim().length > 0;
     return askQuestionsFromPending(row) !== null || !rowHasToolName ? 'question' : 'tool-gate';
 }
-const GENERIC_DECISION_GATE_KINDS = ['human', 'policy_ask'];
+const GENERIC_DECISION_GATE_KINDS = ['human'];
 export function askParkRowStillPending(rows, identity) {
     return rows.some(r => identity.gatedCallId !== undefined
         ? (r.toolCallId ?? r.boundCallId ?? undefined) === identity.gatedCallId

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -19,7 +19,7 @@ export type AutomaticAnswerVerdict = {
     readonly kind: 'unknown';
     readonly why: AutomaticAnswerUnknownWhy;
 };
-export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "rule_unreadable" | "write_protection_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "rule_unreadable" | "target_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "governance_unavailable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
 export declare function foldModeArbitrationRow(classes: Iterable<string>, askFace?: AutomaticAnswerAskFace): CoreModeArbitrationRow;
 export declare function automaticAnswerVerdict(card: object | null | undefined, lane: AutomaticAnswerLane, facts?: AutomaticAnswerFacts | null): AutomaticAnswerVerdict;
 export declare function mandatedApprovalDetailOf(card: object | null | undefined): string;

package/dist/hitl/automaticAnswerVerdict.js

@@ -1,8 +1,9 @@
 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 { currentEngineWord } from '../engineWordRenames.js';
 import { approvalAllowRuleShadowed } from './allowRuleShadow.js';
 import { approvalIsMandated, readApprovalMandate } from './toolApprovalWire.js';
 export const MODE_ARBITRATION = CORE_MODE_ARBITRATION;
@@ -15,9 +16,10 @@ const ORIGIN_IMPLIES_CLASS = Object.freeze({
     ask_rule: 'ask_rule',
     denial_limit_fallback: 'denial_limit_fallback',
 });
-function mandateWordClass(word) {
-    if (word === 'operator_always')
+function mandateWordClass(raw) {
+    if (raw === 'operator_always')
         return 'shell_floor';
+    const word = currentEngineWord(raw);
     return Object.hasOwn(TABLE, word) ? word : undefined;
 }
 const ORDINARY_ROW = CORE_MODE_ARBITRATION.ordinary;
@@ -41,7 +43,8 @@ export function foldModeArbitrationRow(classes, askFace) {
     let sandboxAdmission = true;
     let ruleMayClear = true;
     let hookAskFloor = false;
-    for (const c of classes) {
+    for (const raw of classes) {
+        const c = typeof raw === 'string' ? currentEngineWord(raw) : raw;
         if (!Object.hasOwn(TABLE, c))
             continue;
         const row = TABLE[c];
@@ -102,7 +105,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))
@@ -130,11 +133,12 @@ export function automaticAnswerVerdict(card, lane, facts) {
             return UNKNOWN.classes_malformed;
         if (pair.state === 'absent')
             return UNKNOWN.classes_absent;
-        const folded = foldModeArbitrationRow(pair.classes, face);
+        const classes = pair.classes.map(currentEngineWord);
+        const folded = foldModeArbitrationRow(classes, face);
         let anyKnown = false;
         let firstBlocking;
         let anyUnknown = false;
-        for (const c of pair.classes) {
+        for (const c of classes) {
             if (!Object.hasOwn(TABLE, c)) {
                 anyUnknown = true;
                 continue;
@@ -154,7 +158,7 @@ export function automaticAnswerVerdict(card, lane, facts) {
             return mustAsk('settings_ask_rule');
         if (matched !== false)
             return UNKNOWN.host_not_reported;
-        const releaseReason = CORE_MODE_RELEASE_REASONS.find((r) => pair.classes.includes(r));
+        const releaseReason = CORE_MODE_RELEASE_REASONS.find((r) => classes.includes(r));
         return releaseReason !== undefined ? Object.freeze({ kind: 'may_answer', releaseReason }) : MAY_ANSWER;
     }
     catch {
@@ -168,9 +172,10 @@ export function mandatedApprovalDetailOf(card) {
         const pair = readAskClassPairState(card);
         if (pair.state !== 'pair')
             return mandatedApprovalDetail();
-        if (pair.classes.some((c) => !Object.hasOwn(TABLE, c)))
+        const classes = pair.classes.map(currentEngineWord);
+        if (classes.some((c) => !Object.hasOwn(TABLE, c)))
             return mandatedApprovalDetail();
-        const row = foldModeArbitrationRow(pair.classes);
+        const row = foldModeArbitrationRow(classes);
         if (row.classifierEligible || row.sandboxAdmission)
             return mandatedApprovalDetail();
         return MANDATED_NO_AUTOMATIC_CHECK_DETAIL;

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,41 @@
+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 === 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,21 @@
+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 type DecisionRefusalAskReading = 'settled' | 'not_settled' | 'unreadable';
+interface DecisionRefusalAskFacts {
+    readonly reading: DecisionRefusalAskReading;
+    readonly gateMoved: boolean;
+    readonly wordingHint: boolean;
+}
+export declare function readDecisionRefusalAsk(failure: unknown): DecisionRefusalAskFacts;
+export declare function decisionRefusalAskReading(failure: unknown): DecisionRefusalAskReading;
 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,60 @@
-import { refusalSaysStillPending } from '../engineErrorCodes.js';
+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 { 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) {
+    return readDecisionRefusalAsk(err).reading === 'settled';
+}
+const facts = (reading, gateMoved = false, wordingHint = false) => ({ reading, gateMoved, wordingHint });
+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)
+            return facts('unreadable');
+        flattened = Object.hasOwn(failure, 'kind') && o.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;
+        retriable = refusalRetriableReading(failure);
+        text = flattened ? o.reason : String(failure);
+    }
+    catch {
+        return facts('unreadable');
+    }
+    if (retriable === undefined)
+        return facts('unreadable');
+    if (localCode !== undefined)
+        return facts(localCode === 'no_pending' ? 'settled' : 'not_settled');
+    if (name === 'HitlSafetyError')
+        return facts('not_settled');
+    const code = typeof errorCode === 'string' && errorCode.length > 0 ? errorCode : undefined;
+    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)
+        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))
+        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;
@@ -11,13 +62,21 @@ export function classifyDecisionRefusal(err) {
         return undefined;
     const code = r?.errorCode;
     const errorCode = code !== undefined && DISPLAYABLE_CODE.test(code) ? code : undefined;
-    const standing = status === 404 || status === 410 || (status === 409 && code === ASK_DECIDED_CODE)
+    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));
-    return Object.freeze({ standing, status, ...(errorCode !== undefined ? { errorCode } : {}), ...(transient ? { transient: true } : {}) });
+    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 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.d.ts

@@ -17,7 +17,6 @@ export interface PolicyDenyReasonFacts {
 export declare function policyDenyReason(facts: PolicyDenyReasonFacts): string;
 export declare const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
 export declare const ENGINE_ABORT_TOOL_RESULT = "Operation aborted";
-export declare function toolEndOutputText(output: unknown): string | undefined;
 export interface ParkReattachNotice {
     attempt: number;
     max: number;

package/dist/hitl/frameRouter.js

@@ -1,13 +1,16 @@
 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 { 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 { 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';
@@ -21,7 +24,7 @@ export function policyDenyReason(facts) {
     const one = typeof facts.toolName === 'string' && SENTENCE_TOOL_NAME.test(facts.toolName) ? `this one "${facts.toolName}" call` : 'this one call';
     const flag = typeof facts.allowRuleFlag === 'string' && SENTENCE_TOOL_NAME.test(facts.allowRuleFlag.replace(/^--?/, '')) ? ` (or ${facts.allowRuleFlag})` : '';
     const budgetKnob = typeof facts.budgetSetting === 'string' && SENTENCE_TOOL_NAME.test(facts.budgetSetting) ? facts.budgetSetting : undefined;
-    const cause = facts.cause === 'no_allow_rule' || facts.cause === 'ask_rule' || facts.cause === 'budget' ? facts.cause : 'other';
+    const cause = facts.cause === 'no_allow_rule' || facts.cause === 'ask_rule' || facts.cause === 'engine_ask_rule' || facts.cause === 'budget' ? facts.cause : 'other';
     if (facts.lane === 'dont_ask') {
         const mode = 'denied by the dontAsk permission mode';
         switch (cause) {
@@ -29,6 +32,8 @@ export function policyDenyReason(facts) {
                 return `${mode}: ${one} needed approval, no permission rule allowed it, and this mode refuses anything that would ask — calls that need no approval still run; an allow rule in settings${flag} can approve calls like this ahead of time`;
             case 'ask_rule':
                 return `${mode}: an ask rule matched ${one}, and this mode refuses anything that would ask (an ask rule outranks allow rules) — narrow or remove that ask rule, or use another permission mode to answer it`;
+            case 'engine_ask_rule':
+                return `${mode}: a rule on the engine side, not one of the user's permission rules, asks about ${one}, and this mode refuses anything that would ask — the user's settings cannot approve it; use another permission mode to answer it`;
             case 'budget':
                 return `${mode}: ${one} needed approval, and this session's automatic-approval budget is used up, so saved rules no longer approve calls${budgetKnob !== undefined ? ` — raise ${budgetKnob} before launch to change the cap` : ''}`;
             default:
@@ -42,6 +47,8 @@ export function policyDenyReason(facts) {
             return `${lane}: ${one} needed a person's approval, no permission rule answered it, and ${tail}; a matching allow rule in settings${flag} can approve calls like this ahead of time`;
         case 'ask_rule':
             return `${lane}: an ask rule matched ${one}, so it needed a person's answer, and ${tail}; an ask rule outranks allow rules, so narrow or remove that ask rule, or run the task interactively to answer it`;
+        case 'engine_ask_rule':
+            return `${lane}: a rule on the engine side, not one of the user's permission rules, asks about ${one}, so it needed a person's answer, and ${tail}; the user's settings cannot approve it - run the task interactively to answer it`;
         case 'budget':
             return `${lane}: ${one} needed a person's approval, and this session's automatic-approval budget is used up, so saved rules no longer approve calls; ${tail}${budgetKnob !== undefined ? `; raise ${budgetKnob} before launch to change the cap` : ''}`;
         default:
@@ -71,19 +78,6 @@ function denyStampedEnd(ev, attribution) {
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
-export function toolEndOutputText(output) {
-    if (typeof output === 'string')
-        return output;
-    if (!Array.isArray(output))
-        return undefined;
-    const parts = [];
-    for (const b of output) {
-        const bb = b;
-        if (bb?.type === 'text' && typeof bb.text === 'string')
-            parts.push(bb.text);
-    }
-    return parts.length > 0 ? parts.join('') : undefined;
-}
 function isAskToolLoose(name) {
     return typeof name === 'string' && name.replace(/[\s_-]+/g, '').toLowerCase() === 'askuserquestion';
 }
@@ -266,48 +260,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 +297,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 +349,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>;