@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/hitl/approvalHolds.js

@@ -1,6 +1,8 @@
 import { hostLog } from '../host.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { approvalResolutionOf } from './approvalResolution.js';
+export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
+export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 export function liveCardHoldFor(who) {
     if (nonEmpty(who.approvalId))
@@ -19,13 +21,8 @@ export function liveCardHoldFor(who) {
     }
     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 settledForDurableLane(entry) {
+    return entry !== undefined && !entry.parked;
 }
 export function liveCardAnsweredHow(o) {
     return answeredHowOf(approvalResolutionOf(o));
@@ -47,9 +44,43 @@ export async function awaitLiveCardHolder(hold, signal) {
     finally {
         unsubscribe();
     }
-    return liveCardSettledQuestion(hold, o) ? { ...o, joinedInFlight: true } : undefined;
+    const stillHeld = approvalDecisionHolds.inFlight.get(liveFrameCallKey(hold.identity.approvalId)) === hold;
+    return stillHeld || settledForDurableLane(settledApprovalOf(hold.identity.approvalId)) ? { ...o, joinedInFlight: true } : undefined;
+}
+export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), outcomes: new Map(), clock: 0 };
+export function settledApprovalOf(approvalId) {
+    return typeof approvalId === 'string' && approvalId !== '' ? approvalDecisionHolds.outcomes.get(approvalId) : undefined;
+}
+export function clearSettledApprovals() {
+    approvalDecisionHolds.outcomes.clear();
+}
+export function anyApprovalSettled() {
+    return approvalDecisionHolds.outcomes.size > 0;
+}
+function noteSettled(approvalId, how, parked, outcome) {
+    if (typeof approvalId !== 'string' || approvalId === '')
+        return;
+    if (!APPROVAL_SETTLED_HOWS.includes(how))
+        return;
+    const t = approvalDecisionHolds.outcomes;
+    if (t.has(approvalId))
+        return;
+    t.set(approvalId, Object.freeze({ how, parked, outcome: Object.freeze({ ...outcome }) }));
+    while (t.size > SETTLED_APPROVALS_MAX_ENTRIES) {
+        const oldest = t.keys().next();
+        if (oldest.done === true)
+            break;
+        t.delete(oldest.value);
+    }
+}
+const ENGINE_CLOSED_OUTCOME = Object.freeze({ decision: 'unresolved', retracted: true });
+export function noteEngineClosedApproval(approvalId, parked) {
+    noteSettled(approvalId, 'closed_by_engine', parked, ENGINE_CLOSED_OUTCOME);
+}
+export function settledLiveCardOutcome(approvalId) {
+    const e = settledApprovalOf(approvalId);
+    return e === undefined ? undefined : { ...e.outcome, joinedInFlight: true };
 }
-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;
@@ -76,7 +107,7 @@ export function holdLiveCard(identity, callerSignal, present) {
         if (h.inFlight.get(key) === hold)
             h.inFlight.delete(key);
     };
-    const settle = (give) => {
+    const settle = (give, onLanded) => {
         settled = true;
         unsubscribe();
         const trailing = hold.trailing;
@@ -86,7 +117,11 @@ export function holdLiveCard(identity, callerSignal, present) {
             return;
         }
         give();
-        trailing.then(release, release);
+        trailing.then((landed) => {
+            if (landed === true)
+                onLanded?.();
+            release();
+        }, release);
     };
     let run;
     try {
@@ -95,7 +130,12 @@ export function holdLiveCard(identity, callerSignal, present) {
     catch (e) {
         run = Promise.reject(e);
     }
-    run.then((o) => settle(() => resolveOutcome(o)), (e) => settle(() => rejectOutcome(e)));
+    run.then((o) => {
+        const how = liveCardAnsweredHow(o);
+        if (how === 'answered')
+            noteSettled(identity.approvalId, how, false, o);
+        settle(() => resolveOutcome(o), how === 'interrupted' ? () => noteSettled(identity.approvalId, how, false, o) : undefined);
+    }, (e) => settle(() => rejectOutcome(e)));
     return outcome;
 }
 export async function joinLiveCard(hold, signal) {

package/dist/hitl/askGateWire.js

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

package/dist/hitl/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

@@ -15,10 +15,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';
-    return Object.hasOwn(TABLE, word) ? word : undefined;
+    return Object.hasOwn(TABLE, raw) ? raw : undefined;
 }
 const ORDINARY_ROW = CORE_MODE_ARBITRATION.ordinary;
 function bypassImmuneOn(c, face) {
@@ -41,8 +41,9 @@ export function foldModeArbitrationRow(classes, askFace) {
     let sandboxAdmission = true;
     let ruleMayClear = true;
     let hookAskFloor = false;
-    for (const c of classes) {
-        if (!Object.hasOwn(TABLE, c))
+    for (const raw of classes) {
+        const c = raw;
+        if (typeof c !== 'string' || !Object.hasOwn(TABLE, c))
             continue;
         const row = TABLE[c];
         any = true;
@@ -130,11 +131,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;
+        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 +156,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 +170,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;
+        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/decisionConflict.js

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

package/dist/hitl/decisionRefusal.d.ts

@@ -2,6 +2,14 @@ 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;

package/dist/hitl/decisionRefusal.js

@@ -1,26 +1,66 @@
-import { refusalSaysStillPending } from '../engineErrorCodes.js';
-import { notPendingCauseSaysEnded } from './approvalEndingCause.js';
+import { ASK_GONE, ASK_GONE_PARKED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { notPendingCauseReading } from './approvalEndingCause.js';
+import { GATE_FAILURE_CODES } from './hitlBridge.js';
+import { isAlreadyResolvedGateReason, isCodeClassifiedGateFailure } from './parkResolver.js';
 import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
+import { ownDataField } from '../ownKey.js';
 import { readToolApprovalRespondRefusal } from './toolApprovalWire.js';
 const ASK_DECIDED_CODE = 'conflict.ask_decided';
 const TRANSIENT_STATUSES = new Set([408, 425, 429, 502, 503, 504]);
 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 });
+const PROTOCOL_ERROR_NAMES = Object.freeze({
+    askDecided: 'AskDecidedError',
+    approvalStale: 'ApprovalStaleError',
+    parkedResumeStartup: 'ParkedResumeStartupError',
+});
+export function readDecisionRefusalAsk(failure) {
+    if (typeof failure !== 'object' || failure === null)
+        return facts('not_settled');
+    let flattened, localCode, name, errorCode, status, retriable, text;
     try {
-        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));
+        const slot = (key) => ownDataField(failure, key);
+        if (slot('unreadable') === true)
+            return facts('unreadable');
+        flattened = slot('kind') === 'failed';
+        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');
+        errorCode = slot('errorCode');
+        status = slot('status');
+        retriable = refusalRetriableReading(failure);
+        text = flattened ? slot('reason') : String(failure);
     }
     catch {
-        return false;
+        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;
+    if (isCodeClassifiedGateFailure(code, retriable))
+        return facts('not_settled');
+    const st = typeof status === 'number' && Number.isInteger(status) && status >= 400 && status <= 599 ? status : undefined;
+    if (code === ASK_DECIDED_CODE || code === ASK_GONE || (st === 410 && code !== ASK_GONE_PARKED))
+        return facts('settled');
+    if (st === 404 && notPendingCauseReading(failure) === 'ended')
+        return facts('settled');
+    if (code === undefined && name === PROTOCOL_ERROR_NAMES.askDecided)
+        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)
+        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);
@@ -29,12 +69,13 @@ 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));
+    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,

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

package/dist/hitl/frameRouter.js

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

package/dist/hitl/gateLedger.d.ts

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

package/dist/hitl/gateLedger.js

@@ -13,8 +13,6 @@ export function hasLedgerPositionKey(ev) {
     return (id !== undefined && id !== null) || (seq !== undefined && seq !== null);
 }
 export const PREAMBLE_APPROVALS_MAX_ENTRIES = 4096;
-export const APPROVAL_SETTLED_HOWS = Object.freeze(['answered', 'interrupted', 'closed_by_engine']);
-export const SETTLED_APPROVALS_MAX_ENTRIES = 4096;
 export const START_ARGS_MAX_ENTRIES = 256;
 function normalizeDenyAttribution(a) {
     if (a === undefined)
@@ -90,7 +88,6 @@ export function createGateLedger() {
     let denyStampAttribution;
     let seq;
     const preambleApprovalIds = new Set();
-    const settledApprovalHows = new Map();
     const liveCards = new Set();
     return {
         noteSeq(ev) {
@@ -124,24 +121,6 @@ export function createGateLedger() {
         beginStreamSegment() {
             preambleApprovalIds.clear();
         },
-        noteApprovalSettled(approvalId, how) {
-            if (typeof approvalId !== 'string' || approvalId === '')
-                return;
-            if (!APPROVAL_SETTLED_HOWS.includes(how))
-                return;
-            if (settledApprovalHows.has(approvalId))
-                return;
-            settledApprovalHows.set(approvalId, how);
-            while (settledApprovalHows.size > SETTLED_APPROVALS_MAX_ENTRIES) {
-                const oldest = settledApprovalHows.keys().next();
-                if (oldest.done === true)
-                    break;
-                settledApprovalHows.delete(oldest.value);
-            }
-        },
-        settledApprovals() {
-            return settledApprovalHows;
-        },
         trackLiveCard(phaseOf, handled) {
             const entry = { phaseOf, handled };
             liveCards.add(entry);