@sema-agent/client-core 0.106.0 → 0.108.0

package/dist/hitl/persistedRulesWire.js

@@ -1,11 +1,11 @@
 import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { CORE_RULE_BEHAVIORS } from '../generated/engineFactTables.js';
-import { wireFailureShapeOf } from '../wireFailureShape.js';
+import { slotReadOf, wireFailureShapeOf } from '../wireFailureShape.js';
 import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED } from '../engineErrorCodes.js';
 import { hostLog } from '../host.js';
 import { msg, renderMessage } from '../i18n/translate.js';
-import { guardedRead, readOwnDataValue } from '../ownKey.js';
+import { appendOwnElement, guardedRead, readOwnDataValue } from '../ownKey.js';
 import { observedPermissionRulesWrite, permissionRulesWriteAvailable } from '../permissionRulesWriteCapability.js';
 import { isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
 export function persistedRulesLaneAvailable(baseUrl) {
@@ -17,27 +17,125 @@ export function persistedRulesGovernanceAvailable(baseUrl) {
 export function persistedRulesWriteAvailable(baseUrl) {
     return permissionRulesWriteAvailable(observedPermissionRulesWrite(baseUrl ?? ''));
 }
-export function readCcImportRedeemCounts(result) {
-    const o = (result ?? {});
-    if (Array.isArray(o.members)) {
-        let persisted = 0;
-        let deduped = 0;
-        for (const m of o.members) {
-            const status = m?.status;
-            if (status === 'persisted')
-                persisted += 1;
-            else if (status === 'deduped')
-                deduped += 1;
+const NO_INDETERMINATE = Object.freeze([]);
+const INDETERMINATE_DETAIL_SHOWN_MAX = 400;
+function ownArrayItems(v) {
+    try {
+        if (typeof v !== 'object' || v === null || !Array.isArray(v))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const len = slotReadOf(v, 'length');
+    if (len.presence !== 'present' || typeof len.value !== 'number' || !Number.isSafeInteger(len.value) || len.value < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len.value; i++) {
+        const item = slotReadOf(v, String(i));
+        if (item.presence !== 'present')
+            return undefined;
+        appendOwnElement(out, item.value);
+    }
+    return out;
+}
+function ownNonEmpty(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+}
+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({
+        ...(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;
+    },
+    '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: [], refused: [] };
+    for (const row of rows) {
+        if (typeof row !== 'object' || row === null)
+            return null;
+        const o = slotReadOf(row, 'outcome');
+        const word = o.presence === 'present' ? o.value : undefined;
+        if (typeof word !== 'string' || !Object.hasOwn(RECEIPT_ROW_ARMS, word))
+            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),
+        ...(acc.refused.length === 0 ? {} : { refused: Object.freeze(acc.refused) }),
+    };
+}
+function legacyEnvelopeCountsOf(result) {
+    if (typeof result !== 'object' || result === null)
+        return null;
+    const m = slotReadOf(result, 'members');
+    const rows = m.presence === 'present' ? ownArrayItems(m.value) : undefined;
+    if (rows === undefined)
+        return null;
+    let persisted = 0;
+    let deduped = 0;
+    for (const row of rows) {
+        if (typeof row !== 'object' || row === null)
+            continue;
+        const st = slotReadOf(row, 'status');
+        const status = st.presence === 'present' ? st.value : undefined;
+        if (status === 'persisted')
+            persisted += 1;
+        else if (status === 'deduped')
+            deduped += 1;
+    }
+    return { persisted, deduped, indeterminate: NO_INDETERMINATE };
+}
+export function readCcImportRedeemCounts(body) {
+    try {
+        if (typeof body !== 'object' || body === null)
+            return null;
+        const top = slotReadOf(body, 'members');
+        if (top.presence !== 'absent') {
+            if (top.presence !== 'present')
+                return null;
+            const rows = ownArrayItems(top.value);
+            return rows === undefined ? null : receiptCountsOf(rows);
         }
-        return { persisted, deduped };
+        const legacy = slotReadOf(body, 'result');
+        return legacy.presence === 'present' ? legacyEnvelopeCountsOf(legacy.value) : null;
     }
-    if (Array.isArray(o.persisted) || Array.isArray(o.deduped)) {
-        return {
-            persisted: Array.isArray(o.persisted) ? o.persisted.length : 0,
-            deduped: Array.isArray(o.deduped) ? o.deduped.length : 0,
-        };
+    catch {
+        return null;
     }
-    return null;
 }
 export function classifyRulesFailure(e, context) {
     const { status, errorCode, message, retryAfterSec, committed } = wireFailureShapeOf(e);

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';
@@ -677,6 +678,8 @@ function planReviewSettledVerdict(r) {
         return status !== 'completed' && !gateMoved ? 'still_parked' : 'unconfirmed';
     if (status === 'completed')
         return 'took_effect';
+    if (status === 'running' && r.decision === 'reject')
+        return 'took_effect';
     const newGateHasCard = () => {
         const leg = durableDecideLegOf({ gateKind: r.gateKindAfter ?? null });
         return leg === 'approval' || leg === 'plan_review';
@@ -874,7 +877,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 const bodyStatus = bodyWordOf(body, 'status');
                 const effective = postStatus ?? bodyStatus;
                 statusSeen = effective;
-                effect = planReviewSettledVerdict({ postStatus, bodyStatus, reparked: bodySaysReparked(body), gateBefore, gateAfter, gateKindAfter });
+                effect = planReviewSettledVerdict({ decision, postStatus, bodyStatus, reparked: bodySaysReparked(body), gateBefore, gateAfter, gateKindAfter });
                 const code = bodyWordOf(body, 'errorCode');
                 if (effect === 'still_parked' && postStatus === 'needs_review' && !bodySaysReparked(body)) {
                     outcome =
@@ -892,7 +895,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 }
                 else if (effect === 'took_effect') {
                     outcome =
-                        `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — final status: ${effective} ` +
+                        `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — ${effective === 'completed' ? 'final status' : 'status'}: ${effective} ` +
                             `(${postStatus !== undefined ? 'post-decide re-checked: task left the review gate' : "from the decision's own reply; the post-decide re-check was unavailable"}).`;
                 }
                 else if (effective === 'needs_review' && (gateBefore === undefined || gateAfter === undefined || postStatus !== 'needs_review')) {
@@ -1026,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/sessionAllowRoute.d.ts

@@ -1,2 +1,7 @@
 export type SessionAllowLeg = 'frame' | 'v1' | 'generic';
 export declare function sessionAllowCarried(leg: SessionAllowLeg, approvalId: unknown): boolean;
+export type SessionAllowWhy = 'given' | 'route_cannot_carry' | 'evidence_unreadable' | 'card_unreadable';
+export type CardUnreadableEvidence = readonly string[] | 'absent' | 'unreadable';
+export declare function readCardUnreadableEvidence(card: object): CardUnreadableEvidence;
+export declare function sessionAllowCardReadable(card: object | null | undefined): Exclude<SessionAllowWhy, 'route_cannot_carry'>;
+export declare function sessionAllowEligible(card: object | null | undefined): SessionAllowWhy;

package/dist/hitl/sessionAllowRoute.js

@@ -5,3 +5,45 @@ export function sessionAllowCarried(leg, approvalId) {
         return typeof approvalId === 'string' && approvalId !== '';
     return false;
 }
+export function readCardUnreadableEvidence(card) {
+    try {
+        if (!('unreadableEvidence' in card))
+            return 'absent';
+        const d = Object.getOwnPropertyDescriptor(card, 'unreadableEvidence');
+        const list = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+        return Array.isArray(list) && list.every((k) => typeof k === 'string') ? list : 'unreadable';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function sessionAllowCardReadable(card) {
+    if (typeof card !== 'object' || card === null)
+        return 'card_unreadable';
+    try {
+        if ('cardPayloadUnreadable' in card)
+            return 'card_unreadable';
+    }
+    catch {
+        return 'card_unreadable';
+    }
+    const evidence = readCardUnreadableEvidence(card);
+    if (evidence === 'unreadable')
+        return 'card_unreadable';
+    return evidence !== 'absent' && evidence.length > 0 ? 'evidence_unreadable' : 'given';
+}
+export function sessionAllowEligible(card) {
+    if (typeof card !== 'object' || card === null)
+        return 'card_unreadable';
+    let carried;
+    try {
+        const d = Object.getOwnPropertyDescriptor(card, 'allowSessionCarried');
+        carried = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return 'card_unreadable';
+    }
+    if (carried !== true)
+        return 'route_cannot_carry';
+    return sessionAllowCardReadable(card);
+}

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

@@ -4,6 +4,7 @@ import { readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
 import { permissionsDeclarationReport } from '../permissionsDeclaration.js';
+import { readCardUnreadableEvidence, sessionAllowCardReadable, sessionAllowEligible } from './sessionAllowRoute.js';
 const UNREADABLE = Symbol('unreadable');
 function ownData(v, key) {
     try {
@@ -90,18 +91,17 @@ function enginePremiseOf(card) {
         return 'card_unreadable';
     if (refused.inCard)
         return refused.value === true ? 'remember_refused' : 'remember_unreadable';
-    const evidence = present(card, 'unreadableEvidence');
-    if (evidence === UNREADABLE)
+    const list = readCardUnreadableEvidence(card);
+    if (list === 'unreadable')
         return 'card_unreadable';
-    if (!evidence.inCard)
+    if (list === 'absent')
         return { evidenceUnreadable: false };
-    const list = ownData(card, 'unreadableEvidence');
-    if (!Array.isArray(list) || !list.every((k) => typeof k === 'string'))
-        return 'card_unreadable';
     if (list.includes('rememberRefused'))
         return 'remember_unreadable';
     return { evidenceUnreadable: list.length > 0 };
 }
+const _sessionWhyPin = true;
+void _sessionWhyPin;
 export function standingRowsOf(card, host) {
     if (typeof card !== 'object' || card === null)
         return allClosed('card_unreadable');
@@ -110,11 +110,11 @@ export function standingRowsOf(card, host) {
         if (typeof premise === 'string')
             return allClosed(premise);
         const evidenceUnreadable = premise.evidenceUnreadable;
-        const sessionRow = ownData(card, 'allowSessionCarried') === true;
-        const sessionWhy = sessionRow ? 'given' : 'route_cannot_carry';
+        const sessionWhy = sessionAllowEligible(card);
+        const sessionRow = sessionWhy === 'given';
         let deploymentList;
         if (!sessionRow) {
-            deploymentList = 'route_cannot_carry';
+            deploymentList = sessionWhy;
         }
         else {
             const pair = readAskClassPairState(card);
@@ -143,7 +143,7 @@ export function seatSessionRowOf(card, requestId) {
         const domain = toolPermissionRequestIdDomain(requestId);
         if (domain !== 'live:' && domain !== 'durable:')
             return false;
-        return typeof enginePremiseOf(card) !== 'string';
+        return typeof enginePremiseOf(card) !== 'string' && sessionAllowCardReadable(card) === 'given';
     }
     catch {
         return false;

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';
@@ -15,7 +16,7 @@ import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
 import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
 import { msg, renderMessage } from '../i18n/translate.js';
-import { sessionAllowCarried } from './sessionAllowRoute.js';
+import { sessionAllowCarried, sessionAllowEligible } from './sessionAllowRoute.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.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));
@@ -449,7 +453,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         closeDurableRead(readMark);
     }
     if (!found.ok)
-        return { kind: 'not_sent', lane: 'decide', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}) };
+        return { kind: 'not_sent', lane: 'decide', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}), ...(found.rowVerdict !== undefined ? { rowVerdict: found.rowVerdict } : {}) };
     if (held !== undefined)
         return joinDurableDecision(held, deps, signal);
     const rowIdentity = parkRowHolderIdentity(found.pending, found.gatedCallId);
@@ -500,7 +504,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     const durableRuleOffersAbsence = pending.ruleOffersAbsence;
     hold.presented = true;
     deps.onPresented?.();
-    const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, withUnreadableEvidence(pending, 'row', {
+    const cardRequest = withUnreadableEvidence(pending, 'row', {
         toolName,
         args,
         callKey,
@@ -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 } : {}),
@@ -533,7 +538,8 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
         allowSessionCarried: true,
         grantBinding: readApprovalGrantBinding(pending),
         parkRow: parkRowOf(taskId, pending, gatedCallId),
-    }));
+    });
+    const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, cardRequest);
     hold.phase = 'respond';
     if (rowArgsGap !== undefined && card.kind === 'allow' && card.updatedInput !== undefined) {
         hostLog('error', `liveToolApprovalWire: approval card for ${gatedCallId ?? `task ${taskId}`} returned an edited approval, but the tool input is ${rowArgsGap === 'truncated' ? 'a size marker on the pending row' : 'missing from both the stream and the pending row'} — nothing sent (the park stays pending)`);
@@ -560,10 +566,15 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 let rememberStop;
                 try {
                     let rememberRefused = false;
-                    const approveBody = answerPayloadFor(card, 'decide');
+                    const sessionAllowWhy = sessionAllowEligible(cardRequest);
+                    const sessionDowngraded = card.allowSession === true && sessionAllowWhy !== 'given';
+                    if (sessionDowngraded)
+                        hostLog('debug', `liveToolApprovalWire: ${gatedCallId ?? `task ${taskId}`} session-wide allow taken as allow-once — the card is not eligible (${sessionAllowWhy})`);
+                    const answered = sessionDowngraded ? { ...card, allowSession: false } : card;
+                    const approveBody = answerPayloadFor(answered, 'decide');
                     const { remember: _remember, ...plainApproveBody } = approveBody;
                     void _remember;
-                    emitAnswerCommitted(callKey, 'decide', card, approveBody);
+                    emitAnswerCommitted(callKey, 'decide', answered, approveBody);
                     if (approveBody.remember === 'session') {
                         let sessionReceipt;
                         let sessionDecided = false;
@@ -591,7 +602,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     }
                     const raw = await bridge.decideTool(plainApproveBody, gatedCallId, decideOpts, pending);
                     const receipt = readDecideReceipt(raw);
-                    if (rememberRefused)
+                    if (rememberRefused || sessionDowngraded)
                         surfaceRememberNotApplied();
                     return { kind: 'decided', ...at, decision: 'allow', ...(receipt !== undefined ? { receipt } : {}) };
                 }
@@ -603,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;
@@ -636,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,
@@ -1008,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 } : {}),
     };
 }
@@ -1816,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);
@@ -2038,15 +2062,22 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
     enterLiveRespondPhase(hold);
     const noteCapable = lane?.approvalDecisionNoteCapable === true;
     const denyReasonRead = card.kind === 'deny' ? ((r) => (typeof r === 'string' ? r : undefined))(card.reason) : undefined;
+    const sessionAllowWhy = sessionAllowEligible(facts);
+    const sessionDowngraded = card.kind === 'allow' && card.allowSession === true && sessionAllowWhy !== 'given';
+    if (sessionDowngraded)
+        hostLog('debug', `liveToolApprovalWire: ${approvalId} session-wide allow taken as allow-once — the card is not eligible (${sessionAllowWhy})`);
     const answerSnapshot = card.kind === 'deny'
         ? ((by) => ({ kind: 'deny', ...(denyReasonRead !== undefined ? { reason: denyReasonRead } : {}), ...(by !== undefined ? { settledBy: by } : {}) }))(readApprovalDenySettledBy(card))
-        : card;
+        : sessionDowngraded && card.kind === 'allow'
+            ? { ...card, allowSession: false }
+            : card;
     const basePayload = answerPayloadFor(answerSnapshot, 'respond', { approvalDecisionNoteCapable: noteCapable });
     const decision = basePayload?.decision ?? 'deny';
     if (card.kind === 'allow' && typeof card.note === 'string' && card.note.trim() !== '' && answerCarriage({ callKey: liveFrameCallKey(approvalId) }).allowNote === 'none') {
         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;
@@ -2273,6 +2304,8 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
             logAfterDecided(`liveToolApprovalWire: ${approvalId} allow_session ack rememberApplied=false — grant not stored, surfacing honest notice`);
             surfaceRememberNotApplied();
         }
+        if (replayed === undefined && sessionDowngraded)
+            surfaceRememberNotApplied();
         if (respondOpts.updatedInput !== undefined && applied?.updatedInputForwarded === false) {
             logAfterDecided(`liveToolApprovalWire: ${approvalId} edited args were NOT forwarded (ack.updatedInputForwarded=false) — the tool runs on the ORIGINAL input`);
             surfaceEditNotForwarded();
@@ -2286,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;
+}