@sema-agent/client-core 0.107.0 → 0.108.0

package/dist/hitl/hitlBridge.js

@@ -11,8 +11,7 @@ import { suspendedReopenOf } from './suspendedReopen.js';
 import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisionLedger.js';
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
-import { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.js';
-import { msg, renderMessage } from '../i18n/translate.js';
+import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, unboundWayOutContent } from '../checkpointRowVerdict.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -365,7 +364,7 @@ export class HitlBridge {
         if (typeof boundCallId !== 'string' || boundCallId.length === 0 || typeof boundInputHash !== 'string' || boundInputHash.length === 0) {
             throw new HitlSafetyError(`pending checkpoint ${p.id ?? '<no-id>'} is missing D-1 binding fields ` +
                 `(boundCallId=${String(boundCallId)}, boundInputHash=${String(boundInputHash)}) — ` +
-                `the row itself carries no binding to echo, so ${renderMessage(msg('approval.decide.unboundWayOut'))}`, 'binding_missing');
+                `the row itself carries no binding to echo, so ${unboundWayOutContent(checkpointDeadlineStateOf(p))}`, 'binding_missing');
         }
         return { boundCallId, boundInputHash };
     }

package/dist/hitl/parkResolver.js

@@ -1,18 +1,20 @@
 import { putOwnKey, readOwnDataValue } from '../ownKey.js';
 import { HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, isNoDecisionSurfaceReason, } from './hitlBridge.js';
-import { approvalResolutionDetail, directSafetyStopOf, resolutionOfDecisionFailure } from './approvalResolution.js';
+import { approvalResolutionDetail, approvalResolutionStatusTag, directSafetyStopOf, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny } from './hitlHostSurface.js';
-import { flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
+import { denyAttributionOf, flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
 import { msg, renderMessage } from '../i18n/translate.js';
+import { refusedParkFromError } from '../resumeRefusalCopy.js';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -160,6 +162,10 @@ function failureReasonOf(r) {
         return '';
     return r.detail ?? approvalResolutionDetail(r) ?? r.cause;
 }
+function failsoftReasonOf(r) {
+    const tag = approvalResolutionStatusTag(r);
+    return tag === '' ? failureReasonOf(r) : `${failureReasonOf(r)} ${tag}`;
+}
 function orchestrationEnd(park, gatedCallId, detail) {
     return { kind: 'unsettled', lane: park.gate === 'fs' ? 'decide' : 'ask', cause: 'orchestration', ...(gatedCallId !== undefined ? { gatedCallId } : {}), detail };
 }
@@ -180,10 +186,7 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
             ...(decidedByReading !== undefined ? { approvalDecidedBy: decidedByReading } : {}),
         }, taskId, argsByCallOf(led), ctx.signal, gatedCallId, park.toolName);
         if (outcome.kind === 'decided' && outcome.decision === 'deny' && outcome.gatedCallId) {
-            led.markDenied(outcome.gatedCallId, {
-                ...(outcome.deny?.settledBy !== undefined ? { settledBy: outcome.deny.settledBy } : {}),
-                ...(outcome.deny?.reason !== undefined ? { reason: outcome.deny.reason } : {}),
-            });
+            led.markDenied(outcome.gatedCallId, denyAttributionOf(outcome.deny));
         }
         return outcome;
     }
@@ -283,10 +286,9 @@ export async function resolvePark(park, ctx) {
             ? undefined
             : outcome.kind === 'not_sent' && outcome.cause === 'retracted'
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
-                : failureReasonOf(outcome);
+                : failsoftReasonOf(outcome);
         const noDecisionSurface = outcome.kind === 'not_sent' && outcome.cause === 'card_unavailable' && outcome.detail !== undefined && isNoDecisionSurfaceReason(outcome.detail);
-        const undecidableHere = outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing'));
-        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface, undecidableHere) };
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface, failsoftWayOutOf(outcome)) };
     }
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
@@ -309,17 +311,27 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-function failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut = false) {
+function failsoftWayOutOf(outcome) {
+    if (outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing')))
+        return 'reason';
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && refusedParkFromError(outcome.refusal) !== null)
+        return 'cancel';
+    return 'card';
+}
+function failsoftReasonSentence(park, failedReason, terminal, wayOut = 'card') {
     if (terminal !== undefined)
         return terminal.errorMessage;
     if (failedReason === undefined)
         return undefined;
-    if (reasonCarriesWayOut)
-        return renderMessage(msg('approval.park.stillParked', { gate: park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion', reason: failedReason }));
+    const gate = park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion';
+    if (wayOut === 'reason')
+        return renderMessage(msg('approval.park.stillParked', { gate, reason: failedReason }));
+    if (wayOut === 'cancel')
+        return renderMessage(msg('approval.park.refusedNotResumable', { gate, reason: failedReason }));
     return (`${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
         ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.');
 }
-function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, reasonCarriesWayOut = false) {
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, wayOut = 'card') {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -327,7 +339,7 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, no
             gateAbortedByUser,
         }),
     ];
-    const reason = failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut);
+    const reason = failsoftReasonSentence(park, failedReason, terminal, wayOut);
     if (park.pendingDone) {
         events.push(reason === undefined || noDecisionSurface ? park.pendingDone : inheritFrameBinding(park.pendingDone, { ...park.pendingDone, _sema_park_failed_reason: reason }));
     }
@@ -356,15 +368,12 @@ export function stalledTerminal(park, ctx, stalledRounds, lastStallReason, decid
     return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason) };
 }
 function notifyParkReattach(ctx, attempt, max, reason) {
-    const cb = ctx.deps.onParkReattach;
-    if (typeof cb !== 'function')
-        return;
-    try {
-        cb({ attempt, max, reason });
-    }
-    catch (e) {
-        hostLog('debug', `liveHitlAskWire: onParkReattach threw (${String(e)}) — ignored`);
-    }
+    invokeHostCallbackIsolated('liveHitlAskWire: onParkReattach', () => {
+        const cb = ctx.deps.onParkReattach;
+        if (typeof cb !== 'function' || ctx.signal?.aborted === true)
+            return;
+        return cb.call(ctx.deps, { attempt, max, reason });
+    });
 }
 function transportReasonToken(reason) {
     const m = /(ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|EAI_AGAIN|TimeoutError|AbortError|fetch failed|network)/i.exec(reason);

package/dist/hitl/parkRowBirthWait.d.ts

@@ -11,6 +11,7 @@ export type ParkRowProbe<Row> = {
     rowVerdict?: Exclude<CheckpointRowVerdictReading, {
         readonly kind: 'ok';
     }>;
+    rowTaskId?: string;
 };
 export type ParkRowWaitVerdict<Row> = {
     kind: 'row';
@@ -30,6 +31,7 @@ export type ParkRowWaitVerdict<Row> = {
     rowVerdict?: Exclude<CheckpointRowVerdictReading, {
         readonly kind: 'ok';
     }>;
+    rowTaskId?: string;
 } | {
     kind: 'aborted';
     waitedMs: number;

package/dist/hitl/parkRowBirthWait.js

@@ -103,7 +103,14 @@ export async function waitForParkRowBirth(deps) {
         if (probed.kind === 'row')
             return { kind: 'row', row: probed.row, waitedMs: now() - startedAt, probes };
         if (probed.kind === 'settled') {
-            return { kind: 'settled', reason: probed.reason, waitedMs: now() - startedAt, probes, ...(probed.rowVerdict !== undefined ? { rowVerdict: probed.rowVerdict } : {}) };
+            return {
+                kind: 'settled',
+                reason: probed.reason,
+                waitedMs: now() - startedAt,
+                probes,
+                ...(probed.rowVerdict !== undefined ? { rowVerdict: probed.rowVerdict } : {}),
+                ...(probed.rowTaskId !== undefined ? { rowTaskId: probed.rowTaskId } : {}),
+            };
         }
         lastReason = probed.reason;
         const remainingMs = budgetMs - (now() - startedAt);

package/dist/hitl/persistedRulesWire.d.ts

@@ -31,12 +31,16 @@ export interface CcImportRedeemRuleKey {
     readonly rule: string;
     readonly scope: string;
 }
+export interface CcImportRedeemRefused {
+    readonly key?: CcImportRedeemRuleKey;
+}
 export interface CcImportRedeemCounts {
     persisted: number;
     deduped: number;
     indeterminate: readonly CcImportRedeemIndeterminate[];
+    refused?: readonly CcImportRedeemRefused[];
 }
-export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'indeterminate';
+export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'refused' | 'indeterminate';
 export declare function readCcImportRedeemCounts(body: unknown): CcImportRedeemCounts | null;
 export type RulesFailure = {
     kind: 'lane-unavailable';

package/dist/hitl/persistedRulesWire.js

@@ -43,21 +43,29 @@ function ownNonEmpty(o, key) {
     const r = slotReadOf(o, key);
     return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
 }
-function indeterminateRowOf(row) {
+function ruleKeyOfRow(row) {
     const k = slotReadOf(row, 'key');
     const keyObj = k.presence === 'present' && typeof k.value === 'object' && k.value !== null ? k.value : undefined;
     const behavior = keyObj === undefined ? undefined : ownNonEmpty(keyObj, 'behavior');
     const rule = keyObj === undefined ? undefined : ownNonEmpty(keyObj, 'rule');
     const scope = keyObj === undefined ? undefined : ownNonEmpty(keyObj, 'scope');
+    return behavior !== undefined && rule !== undefined && scope !== undefined ? Object.freeze({ behavior, rule, scope }) : undefined;
+}
+function indeterminateRowOf(row) {
+    const key = ruleKeyOfRow(row);
     const reason = ownNonEmpty(row, 'reason');
     const d = slotReadOf(row, 'detail');
     const shown = d.presence === 'present' && typeof d.value === 'string' ? displayUntrusted(d.value, { max: INDETERMINATE_DETAIL_SHOWN_MAX }) : undefined;
     return Object.freeze({
-        ...(behavior !== undefined && rule !== undefined && scope !== undefined ? { key: Object.freeze({ behavior, rule, scope }) } : {}),
+        ...(key !== undefined ? { key } : {}),
         ...(reason !== undefined ? { reason } : {}),
         ...(shown !== undefined && shown.trim() !== '' ? { detail: shown } : {}),
     });
 }
+function refusedRowOf(row) {
+    const key = ruleKeyOfRow(row);
+    return Object.freeze(key !== undefined ? { key } : {});
+}
 const RECEIPT_ROW_ARMS = {
     persisted: (acc) => {
         acc.persisted += 1;
@@ -65,12 +73,15 @@ const RECEIPT_ROW_ARMS = {
     'no-op': (acc) => {
         acc.deduped += 1;
     },
+    refused: (acc, row) => {
+        appendOwnElement(acc.refused, refusedRowOf(row));
+    },
     indeterminate: (acc, row) => {
         appendOwnElement(acc.indeterminate, indeterminateRowOf(row));
     },
 };
 function receiptCountsOf(rows) {
-    const acc = { persisted: 0, deduped: 0, indeterminate: [] };
+    const acc = { persisted: 0, deduped: 0, indeterminate: [], refused: [] };
     for (const row of rows) {
         if (typeof row !== 'object' || row === null)
             return null;
@@ -80,7 +91,12 @@ function receiptCountsOf(rows) {
             return null;
         RECEIPT_ROW_ARMS[word](acc, row);
     }
-    return { persisted: acc.persisted, deduped: acc.deduped, indeterminate: acc.indeterminate.length === 0 ? NO_INDETERMINATE : Object.freeze(acc.indeterminate) };
+    return {
+        persisted: acc.persisted,
+        deduped: acc.deduped,
+        indeterminate: acc.indeterminate.length === 0 ? NO_INDETERMINATE : Object.freeze(acc.indeterminate),
+        ...(acc.refused.length === 0 ? {} : { refused: Object.freeze(acc.refused) }),
+    };
 }
 function legacyEnvelopeCountsOf(result) {
     if (typeof result !== 'object' || result === null)

package/dist/hitl/planReviewWire.js

@@ -1,5 +1,6 @@
 import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, unregisterLocalQuestionResponder, hasLocalQuestionResponder, hasQuestionOverlayFor, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
 import { clientHasVerbs, engineWireFor, noAnswerKindOf, sendOnce } from '../engineWireFor.js';
 import { engineWireTarget } from '../engineWireTarget.js';
@@ -1028,22 +1029,17 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         hostLog('debug', `planReviewWire: outcome enqueue threw: ${String(e)}`);
     }
     if (onOutcome !== undefined) {
-        try {
-            onOutcome({
-                taskId,
-                dispatchNo,
-                decision: semanticDecision,
-                effect,
-                ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}),
-                detail: outcome,
-                tail,
-                prompt,
-                ...(statusSeen !== undefined ? { status: statusSeen } : {}),
-            });
-        }
-        catch (e) {
-            hostLog('debug', `planReviewWire: onOutcome callback threw for task ${taskId} (ignored): ${String(e)}`);
-        }
+        invokeHostCallbackIsolated(`planReviewWire: onOutcome callback (task ${taskId})`, () => onOutcome({
+            taskId,
+            dispatchNo,
+            decision: semanticDecision,
+            effect,
+            ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}),
+            detail: outcome,
+            tail,
+            prompt,
+            ...(statusSeen !== undefined ? { status: statusSeen } : {}),
+        }));
     }
 }
 function reopenIdSuffix() {

package/dist/hitl/policyDenyCause.d.ts

@@ -0,0 +1,3 @@
+export declare const POLICY_DENY_CAUSES: readonly ["no_approval_ui", "dont_ask", "deny_rule", "engine_floor"];
+export type PolicyDenyCause = (typeof POLICY_DENY_CAUSES)[number];
+export declare function readPolicyDenyCause(decision: object | null | undefined): PolicyDenyCause | undefined;

package/dist/hitl/policyDenyCause.js

@@ -0,0 +1,16 @@
+export const POLICY_DENY_CAUSES = Object.freeze(['no_approval_ui', 'dont_ask', 'deny_rule', 'engine_floor']);
+export function readPolicyDenyCause(decision) {
+    if (decision === null || typeof decision !== 'object')
+        return undefined;
+    let d;
+    try {
+        d = Object.getOwnPropertyDescriptor(decision, 'policyCause');
+    }
+    catch {
+        return undefined;
+    }
+    if (d === undefined || !Object.hasOwn(d, 'value'))
+        return undefined;
+    const v = d.value;
+    return typeof v === 'string' && POLICY_DENY_CAUSES.includes(v) ? v : undefined;
+}

package/dist/hitl/sessionPolicyDeliverable.js

@@ -12,7 +12,7 @@ const WITHHELD_NOTICE = {
     qualified_deny: 'Not written to this session’s rule record: that record holds whole tool names and command names only, and this rule has a part in parentheses it cannot carry — recording just the name could block more than this rule does.',
     peer_wide: 'Not written to this session’s rule record: this rule names a server or agent peer without naming one of its tools, and an engine that matches that record by exact tool name would block none of that peer’s tools.',
     wildcard: 'Not written to this session’s rule record: this rule uses a wildcard (*), and an engine that matches that record by exact tool name would block none of the tools it covers.',
-    not_a_tool_name: 'Not written to this session’s rule record: this entry is not exactly one tool name — it is empty, not text, has spaces around the name, is not a single tool name in rule syntax (for example it contains a backslash or a parenthesis, or is longer than a rule can be), or spells its server or agent peer part in a way the engine never uses when naming tools (for example with a dot or a space), so no tool would ever match it.',
+    not_a_tool_name: 'Not written to this session’s rule record: this entry is not exactly one tool name — it is empty, not text, has spaces around the name, is not a single tool name in rule syntax (for example it contains a backslash or a parenthesis, or is longer than a rule can be), or spells its server or agent peer part in a form this record does not accept (for example with a dot or a space) · This record does not take entries of that form; record the exact name of a single tool instead.',
     legacy_tool_name: `Not written to this session’s rule record: unless a tool by exactly this name is available, the engine refuses it — it is a retired tool name, or it contains "__" but does not start with ${PREFIXES_IN_PROSE} — and with it in that record every later run of this session would fail at startup until that entry is removed from the record. ${REFUSED_NAME_FIX}`,
     not_in_roster: 'Not written to this session’s rule record: the tool roster supplied for this check has no tool this rule would block — no tool by exactly this name, as a name or an alias, with letter case counted, and, where the engine also reads the name as naming every tool of a server (a server whose own name contains "__"), no tool of that server either — it may be misspelled, or name a tool this deployment does not provide — so recorded as it is it would block nothing here.',
     namespace_covering_unconfirmed: msg('session.policy.withheld.namespaceCoveringUnconfirmed'),

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,4 +1,6 @@
 import { type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
+import { type ApprovalAskReason } from './approvalAskers.js';
+export type { ApprovalAskReason, ApprovalAskReasonByHook, ApprovalAskReasonByPolicy } from './approvalAskers.js';
 import { readApprovalCardWord, type ApprovalCardWord } from './approvalCardReading.js';
 import { type ApprovalAllowRuleShadow } from './allowRuleShadow.js';
 import { CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
@@ -9,6 +11,7 @@ import { type ApprovalResolution } from './approvalResolution.js';
 import { type ApprovalMandateWord } from '../gateVocabulary.js';
 import type { ToolPermissionRequest } from '../seatContract.js';
 import { type ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
+import { type PolicyDenyCause } from './policyDenyCause.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS } from '@sema-agent/sdk';
 import type { ApprovalDecidedBy, ApprovalCardDelegation, ToolApprovalDecision as SdkToolApprovalDecision, ToolApprovalRespondAck, ToolApprovalRespondReplayed, PersistedRuleAnchor, RuleOfferMatch, RuleOfferBatchMember, RuleOfferUncoveredDetail, RuleOfferUncoveredReason, AskOrigin, RuleOffersAbsence, DenialLimitKind, DenialLimitFallback, ToolApprovalFrame, ApprovalRequestFrame, RuleOffer as SdkRuleOffer } from '@sema-agent/sdk';
 export declare function toolNameIsFsWrite(name: string): boolean;
@@ -71,6 +74,7 @@ export interface ApprovalCardDenyDecision {
     kind: 'deny';
     reason?: string;
     settledBy?: ApprovalDenySettledBy;
+    policyCause?: PolicyDenyCause;
 }
 export declare const APPROVAL_DENY_SETTLED_BY_WORDS: readonly ["human", "policy"];
 export type ApprovalDenySettledBy = (typeof APPROVAL_DENY_SETTLED_BY_WORDS)[number];
@@ -125,6 +129,8 @@ export interface ApprovalCardRequest {
     approvalCard?: ApprovalCardWord;
     askClass?: string;
     classes?: readonly string[];
+    agentId?: string;
+    askReasons?: readonly ApprovalAskReason[];
     boundGrants?: BoundSkillGrantsWire;
     grantBinding?: ApprovalGrantBinding;
     unreadableEvidence?: readonly string[];
@@ -163,7 +169,7 @@ export declare function approvalCardPortFor(sessionKey: string): ApprovalCardPor
 export declare function __resetSettledApprovalsForTests(): void;
 export declare function _resetApprovalCardPortForTest(): void;
 export declare function surfaceApprovalCard(req: ApprovalCardRequest): Promise<ApprovalCardDecision>;
-declare const REMEMBER_REFUSAL_CODES: readonly ["remember_not_in_proof", "capability.store_required", "decide.workflow_remember_unsupported", "decide.parked_remember_unsupported"];
+declare const REMEMBER_REFUSAL_CODES: readonly ["remember_not_in_proof", "capability.store_required", "decide.workflow_remember_unsupported", "decide.parked_remember_unsupported", "remember_requires_binding"];
 export type RememberRefusalCode = (typeof REMEMBER_REFUSAL_CODES)[number];
 export declare function rememberRefusalOf(error: unknown): RememberRefusalCode | undefined;
 export declare function surfaceFsApprovalAndDecide(deps: FsApprovalWireDeps, taskId: string, argsByCall: Map<string, unknown>, signal?: AbortSignal, parkGatedCallId?: string, parkToolName?: string): Promise<ApprovalResolution>;
@@ -276,7 +282,7 @@ export declare function approvalSupersedesDetail(card: Pick<ApprovalCardRequest,
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOfferReading[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOfferReading[] | undefined;
-export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
+export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'agentId' | 'askReasons' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
 export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'argsRewritten' | 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable'>;
 export interface ApprovalCardFrameFactsOptions {
     readonly streamArgs?: object;

package/dist/hitl/toolApprovalWire.js

@@ -7,6 +7,7 @@ import { trimEditedRuleText } from './editedRuleTextPrecheck.js';
 import { appendOwnElement, guardedRead, readAskOrigin, readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { ownReadingSlot } from '../engineWireFor.js';
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPair } from './askClassPair.js';
+import { approvalAgentIdOf, approvalAskReasonsOf } from './approvalAskers.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { approvalWindowKeysOf, readApprovalCardWord, readRequiresRealApproval } from './approvalCardReading.js';
 import { readAllowRuleShadowFromWire, retiredAllowRuleShadowKeyPresent, RETIRED_SHADOW_EVIDENCE_LABEL } from './allowRuleShadow.js';
@@ -28,6 +29,7 @@ import { parkRowDeadlineState } from './parkExpiryJudgements.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
+import { readPolicyDenyCause } from './policyDenyCause.js';
 import { slotPresenceOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { APPROVAL_LIVE_FACE_KEYS, approvalLiveFaceOf, hasOwnStrictTrue } from './approvalLiveFace.js';
 import { subagentSourceSessionOf } from './subagentSource.js';
@@ -157,11 +159,13 @@ function cardPortMissReason() {
         return APPROVAL_CARD_PORT_KEY_MISMATCH_REASON;
     return NO_APPROVAL_CARD_PORT_REASON;
 }
+const LEGACY_REMEMBER_REFUSAL_CODE = 'remember_requires_binding';
 const REMEMBER_REFUSAL_CODES = Object.freeze([
     'remember_not_in_proof',
     'capability.store_required',
     DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
     'decide.parked_remember_unsupported',
+    LEGACY_REMEMBER_REFUSAL_CODE,
 ]);
 export function rememberRefusalOf(error) {
     return rememberRefusalIn(readWireErrorCodeReading(error));
@@ -517,6 +521,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
         ...approvalLiveFaceOf(pending).facts,
         ...((w) => (w !== undefined ? { approvalCard: w } : {}))(readApprovalCardWord(pending)),
         ...(readAskClassPair(pending) ?? {}),
+        ...((r) => (r !== undefined ? { askReasons: r } : {}))(approvalAskReasonsOf(pending)),
         ...(pending.gateKind === 'irreversible_ask' ? { irreversibleParkGate: true } : {}),
         ...(pending.hasBidiControls === true ? { hasBidiControls: true } : {}),
         ...(ruleOffersReadOnly !== undefined ? { ruleOffersReadOnly } : {}),
@@ -609,6 +614,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 }
             case 'deny': {
                 const denySettledByForWire = readApprovalDenySettledBy(card);
+                const denyPolicyCauseForWire = readPolicyDenyCause(card);
                 const attributionKeys = decisionAttributionKeyOf(decidedByReading, denySettledByForWire);
                 const denyReasonSnapshot = ((r) => (typeof r === 'string' ? r : undefined))(card.reason);
                 let lastSendCarriedAttribution = false;
@@ -642,7 +648,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     const attributionDropped = ladder.dropped;
                     const attributionRenamed = ladder.renamed;
                     const receipt = readDecideReceipt(raw);
-                    const deny = denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed);
+                    const deny = denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed, denyPolicyCauseForWire);
                     return {
                         kind: 'decided',
                         ...at,
@@ -1014,14 +1020,16 @@ function readDecidedByReadingOf(holder) {
 function decidedByReadingSnapshotOf(holder) {
     return approvalDecidedByAdmitted(readDecidedByReadingOf(holder)) ? Object.freeze({ kind: 'present', value: true }) : undefined;
 }
-function denyFactsOf(settledBy, reasonSnapshot, dropped, renamed) {
+function denyFactsOf(settledBy, reasonSnapshot, dropped, renamed, policyCauseSnapshot) {
     const reason = reasonSnapshot !== undefined && reasonSnapshot.trim() !== '' ? reasonSnapshot : undefined;
     const attributionKey = dropped ? 'dropped' : renamed ? 'renamed' : undefined;
+    const policyCause = settledBy === 'policy' ? policyCauseSnapshot : undefined;
     if (settledBy === undefined && reason === undefined && attributionKey === undefined)
         return undefined;
     return {
         ...(settledBy !== undefined ? { settledBy } : {}),
         ...(reason !== undefined ? { reason } : {}),
+        ...(policyCause !== undefined ? { policyCause } : {}),
         ...(attributionKey !== undefined ? { attributionKey } : {}),
     };
 }
@@ -1822,6 +1830,16 @@ function cardFactsOf(carrier, leg, opts, liveFacts, approvalId) {
             if (w !== undefined)
                 out.approvalCard = w;
         });
+        v1Bit(() => {
+            const id = approvalAgentIdOf(carrier);
+            if (id !== undefined)
+                out.agentId = id;
+        });
+        v1Bit(() => {
+            const reasons = approvalAskReasonsOf(carrier);
+            if (reasons !== undefined)
+                out.askReasons = reasons;
+        });
     }
     v1Bit(() => {
         const pair = readAskClassPair(carrier);
@@ -2059,6 +2077,7 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
         hostLog('debug', `liveToolApprovalWire: ${approvalId} card carried a note on Yes (len=${card.note.length}) — this engine has no field that brings it to the model, so it was not sent`);
     }
     const denySettledByForWire = card.kind === 'deny' ? readApprovalDenySettledBy(card) : undefined;
+    const denyPolicyCauseForWire = card.kind === 'deny' ? readPolicyDenyCause(card) : undefined;
     const attributionKeys = decision === 'deny' ? decisionAttributionKeyOf(decidedByReading, denySettledByForWire) : {};
     const sentAttributionKey = carriesAttributionKey(attributionKeys);
     let lastSendCarriedAttribution = sentAttributionKey;
@@ -2300,7 +2319,7 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
                 'this answer was not delivered, reporting the earlier decision');
             return { kind: 'decided', lane: 'respond', decision: replayed.decision, ack: replayed };
         }
-        const deny = decision === 'deny' ? denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed) : undefined;
+        const deny = decision === 'deny' ? denyFactsOf(denySettledByForWire, denyReasonSnapshot, attributionDropped, attributionRenamed, denyPolicyCauseForWire) : undefined;
         return { kind: 'decided', lane: 'respond', decision, ...(ack !== undefined ? { ack } : {}), ...(deny !== undefined ? { deny } : {}) };
     }
     catch (e) {

package/dist/hooksReaderGenerations.d.ts

@@ -0,0 +1 @@
+export declare function hooksReaderNotReadKeys(serverVersion: string | undefined): readonly string[];

package/dist/hooksReaderGenerations.js

@@ -0,0 +1,12 @@
+import { engineVersionTier } from './supportFloor.js';
+const HOOKS_READER_GENERATIONS = Object.freeze([
+    Object.freeze({ from: '7.139.0', below: '7.147.0', notRead: Object.freeze(['onFailure']) }),
+]);
+const HOOKS_READER_FAIL_CLOSED = Object.freeze([...new Set(HOOKS_READER_GENERATIONS.flatMap((g) => g.notRead))]);
+export function hooksReaderNotReadKeys(serverVersion) {
+    for (const g of HOOKS_READER_GENERATIONS) {
+        if (engineVersionTier(serverVersion, g.from) === 'engine' && engineVersionTier(serverVersion, g.below) === 'legacy')
+            return g.notRead;
+    }
+    return HOOKS_READER_FAIL_CLOSED;
+}

package/dist/hooksWireCaps.js

@@ -1,4 +1,5 @@
-import { engineCapNestedTrue, engineCapState, engineCapValue } from './engineCapsCache.js';
+import { engineCapNestedTrue, engineCapState, engineCapString, engineCapValue } from './engineCapsCache.js';
+import { hooksReaderNotReadKeys } from './hooksReaderGenerations.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { capForDisplay, collapseLabel } from './fleetTaskDesc.js';
 import { hostLog } from './host.js';
@@ -185,7 +186,8 @@ export function hooksWirePlan(opts) {
         const types = typesByEvent.get(event);
         return types === undefined || (typeof type === 'string' && types.has(type));
     };
-    return buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUserOf(o), suppressedLocallyOf(o), compactionOnShellOf(o));
+    const readerNotRead = hooksReaderNotReadKeys(engineCapString(o.baseUrl, 'version'));
+    return buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUserOf(o), suppressedLocallyOf(o), readerNotRead, compactionOnShellOf(o));
 }
 function taskHooksCapability(baseUrl) {
     const v = engineCapValue(baseUrl, 'taskSettings');
@@ -298,7 +300,7 @@ function withheldRowsOf(candidates, trust, layers) {
     }
     return rows;
 }
-function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppressedLocally, compactionOnShell = false) {
+function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppressedLocally, readerNotRead, compactionOnShell = false) {
     const settingsDropped = [];
     const settingsVerdicts = [];
     const settingsExcluded = [];
@@ -344,6 +346,7 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
             shellRuns,
             promptAuthoredByUser,
             occupied: new Map(),
+            readerNotRead,
         }));
         if (d === undefined)
             return planOf('failed', undefined);
@@ -465,7 +468,7 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
                 continue;
             if (!Array.isArray(groups) || groups.length === 0)
                 continue;
-            const kept = filterSettingsHookGroups(source, event, groups, engine.pluginHooksCapable === true, (type) => shellRuns(event, type), judge, layer.mask);
+            const kept = filterSettingsHookGroups(source, event, groups, engine.pluginHooksCapable === true, (type) => shellRuns(event, type), judge, readerNotRead, layer.mask);
             settingsDropped.push(...kept.drops);
             settingsVerdicts.push(...kept.verdicts);
             settingsExcluded.push(...kept.excluded);
@@ -531,6 +534,7 @@ function buildHooksWirePlan(read, engine, shellRuns, promptAuthoredByUser, suppr
             promptAuthoredByUser,
             occupied,
             ...(suppressedLocally !== undefined ? { suppressedLocally } : {}),
+            readerNotRead,
         });
     });
     if (d === undefined)