@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,12 +1,10 @@
 import { CONFIG_LEGACY_TOOL_NAME, RULES_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { ruleCompileVerdict } from '../ruleCompileVerdict.js';
-import { protocolSegmentOf } from '../protocolSegment.js';
+import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX, RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
-import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from '../generated/toolNameTables.js';
-import { isEngineRefusedToolName } from '../engineRefusedToolName.js';
+import { CORE_PROTOCOL_PREFIXES } from '../generated/toolNameTables.js';
 const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
-const ENGINE_RETIRED_TOOL_NAMES = CORE_RETIRED_TOOL_CURRENT_NAMES;
 const WITHHELD_NOTICE = {
     ask_no_bucket: 'Not written to this session’s rule record: that record only holds rules that block outright, and this rule asks before running instead — recording it as a block would change what it means.',
     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.',
@@ -37,11 +35,8 @@ function withheldWhyOf(rule) {
     }
     if (rule.trim() !== rule)
         return 'not_a_tool_name';
-    if (isEngineRefusedToolName(rule))
-        return 'legacy_tool_name';
     return undefined;
 }
-export { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 function suppliedRosterNames(opts) {
     if (opts === undefined || opts === null)
         return 'absent';
@@ -95,27 +90,32 @@ export function sessionPolicyDeliverable(behavior, rules, opts) {
             continue;
         }
         let why = withheldWhyOf(r);
+        let currentName;
         if (why === undefined) {
-            const grammar = ruleCompileVerdict(r, 'deny');
-            if (grammar === 'unknown')
+            const verdict = ruleToolNameVerdictOf(r);
+            if (verdict.kind === 'unknown')
                 return unreadable();
-            if (grammar === 'refused')
+            if (verdict.kind === 'retired' || verdict.kind === 'unprefixed_namespace') {
+                why = 'legacy_tool_name';
+                if (verdict.kind === 'retired')
+                    currentName = verdict.currentName;
+            }
+            else if (verdict.kind === 'unmintable_segment')
                 why = 'not_a_tool_name';
         }
-        if (why === undefined && COVERING_NAMESPACE_PREFIXES.some((p) => r.startsWith(p))) {
-            const segment = protocolSegmentOf(r);
-            if (segment.kind === 'empty' || segment.kind === 'unminted')
-                why = 'not_a_tool_name';
-            else if (segment.kind === 'unknown')
+        if (why === undefined) {
+            const grammar = ruleCompileVerdict(r, 'deny').kind;
+            if (grammar === 'unknown')
                 return unreadable();
+            if (grammar === 'refused')
+                why = 'not_a_tool_name';
         }
         if (why === undefined && mounted !== undefined && !mounted.has(r))
             why = 'not_in_roster';
         if (why === undefined)
             exact.push(r);
         else {
-            const currentName = why === 'legacy_tool_name' ? ENGINE_RETIRED_TOOL_NAMES.get(r) : undefined;
-            withheld.push(typeof currentName === 'string' ? { rule: r, why, currentName } : { rule: r, why });
+            withheld.push(why === 'legacy_tool_name' && currentName !== undefined ? { rule: r, why, currentName } : { rule: r, why });
         }
     }
     if (withheld.length > 0 || exact.length === 0)

package/dist/hitl/sessionPolicyWire.d.ts

@@ -132,6 +132,8 @@ export type SessionPolicyRemovalOutcome = {
 } | {
     kind: 'nothing_to_remove';
     rev: number;
+} | {
+    kind: 'judge_failed';
 } | {
     kind: 'loosen_forbidden';
     message: string;

package/dist/hitl/sessionPolicyWire.js

@@ -1,6 +1,6 @@
 import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { hostLog } from '../host.js';
-import { isEngineRefusedToolName } from './sessionPolicyDeliverable.js';
+import { ruleToolNameVerdictOf } from '../protocolSegment.js';
 import { RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
 import { RULES_LEGACY_TOOL_NAME, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
@@ -434,7 +434,14 @@ function withoutRefusedEntries(prior, mounted) {
         const kept = [];
         const seen = new Set();
         for (const x of list) {
-            if (!isEngineRefusedToolName(x) || mounted.has(x)) {
+            if (mounted.has(x)) {
+                kept.push(x);
+                continue;
+            }
+            const kind = ruleToolNameVerdictOf(x).kind;
+            if (kind === 'unknown')
+                return 'judge_failed';
+            if (kind === 'current') {
                 kept.push(x);
                 continue;
             }
@@ -479,7 +486,10 @@ async function attemptRemoval(facade, sessionId, mounted, opts) {
         return { done: removalFailed(read.failure, 'read') };
     if (read.kind === 'malformed')
         return { done: { kind: 'read_failed', why: 'read_unreadable', message: read.detail } };
-    const { next, removed } = withoutRefusedEntries(read.rules, mounted);
+    const judged = withoutRefusedEntries(read.rules, mounted);
+    if (judged === 'judge_failed')
+        return { done: { kind: 'judge_failed' } };
+    const { next, removed } = judged;
     if (removed.length === 0)
         return { done: { kind: 'nothing_to_remove', rev: read.rev } };
     let receipt;
@@ -563,6 +573,8 @@ export function sessionPolicyRemovalNotice(outcome) {
         }
         case 'nothing_to_remove':
             return 'This session’s rule record holds no entry naming a tool the engine refuses that the supplied roster does not mount, so nothing was changed. If runs still fail at startup over a refused tool name, that entry is set somewhere this record does not cover — the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules — or it is a name the engine refuses that this version does not yet recognise, or the failing run does not mount a tool the supplied roster has under that name.';
+        case 'judge_failed':
+            return 'Nothing was changed: this client could not check which entries in this session’s rule record name a tool the engine refuses (its copy of the engine’s tool-name check is unavailable or gave no clear answer), so it removed none rather than guess. Removing them needs that check available in this client.';
         case 'loosen_forbidden':
             return 'The engine refused to take these entries out of this session’s rule record: on this engine only an operator can remove entries from it, so the record is unchanged. Ask an operator to remove them, or continue in a new session.';
         case 'conflict':

package/dist/hitl/standingRows.d.ts

@@ -0,0 +1,19 @@
+export type StandingRowWhy = 'given' | 'card_unreadable' | 'remember_refused' | 'remember_unreadable' | 'route_cannot_carry' | 'classes_unreadable' | 'not_deployment_list_question' | 'evidence_unreadable' | 'offers_unreadable' | 'engine_lane_closed' | 'args_unavailable' | 'grant_binding' | 'tool_name_unreadable' | 'rule_cannot_clear' | 'host_fact_missing' | 'face_not_generic' | 'rule_not_sent';
+export type StandingPersistentRow = 'engine_offer' | 'local_whole_tool' | 'none';
+export interface StandingRowsWhy {
+    readonly session: StandingRowWhy;
+    readonly persistent: StandingRowWhy;
+    readonly deploymentList: StandingRowWhy;
+}
+export interface StandingRows {
+    readonly sessionRow: boolean;
+    readonly persistentRow: StandingPersistentRow;
+    readonly deploymentListSessionRow: boolean;
+    readonly why: StandingRowsWhy;
+}
+export interface StandingRowsHostFacts {
+    readonly cardFace?: string;
+    readonly wholeToolRuleSent?: boolean;
+}
+export declare function standingRowsOf(card: object | null | undefined, host?: StandingRowsHostFacts | null): StandingRows;
+export declare function seatSessionRowOf(card: object | null | undefined, requestId: string | undefined): boolean;

package/dist/hitl/standingRows.js

@@ -0,0 +1,148 @@
+import { readAskClassPairState } from './askClassPair.js';
+import { automaticAnswerVerdict } from './automaticAnswerVerdict.js';
+import { readRuleOffers } from './toolApprovalWire.js';
+import { toolPermissionRequestIdDomain } from '../seatContract.js';
+const DEPLOYMENT_LIST_ASK_CLASSES = Object.freeze(['ask_rule']);
+const UNREADABLE = Symbol('unreadable');
+function ownData(v, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasKey(v, key) {
+    try {
+        return { inCard: key in v };
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function present(v, key) {
+    try {
+        const inCard = key in v;
+        return { inCard, value: inCard ? v[key] : undefined };
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function freezeRows(sessionRow, persistentRow, deploymentListSessionRow, why) {
+    return Object.freeze({ sessionRow, persistentRow, deploymentListSessionRow, why: Object.freeze({ ...why }) });
+}
+function allClosed(why) {
+    return freezeRows(false, 'none', false, { session: why, persistent: why, deploymentList: why });
+}
+function persistentRowOf(card, host, evidenceUnreadable) {
+    if (evidenceUnreadable)
+        return { row: 'none', why: 'evidence_unreadable' };
+    for (const key of ['ruleOffers', 'ruleOffersReadOnly']) {
+        const p = hasKey(card, key);
+        if (p === UNREADABLE)
+            return UNREADABLE;
+        if (!p.inCard)
+            continue;
+        const offers = readRuleOffers(ownData(card, key));
+        if (offers === undefined || offers.length === 0)
+            return { row: 'none', why: 'offers_unreadable' };
+        return { row: 'engine_offer', why: 'given' };
+    }
+    const absence = present(card, 'ruleOffersAbsence');
+    if (absence === UNREADABLE)
+        return UNREADABLE;
+    if (absence.inCard)
+        return { row: 'none', why: 'engine_lane_closed' };
+    const blind = present(card, 'argsUnavailable');
+    if (blind === UNREADABLE)
+        return UNREADABLE;
+    if (blind.inCard)
+        return { row: 'none', why: 'args_unavailable' };
+    if (ownData(card, 'grantBinding') !== 'none')
+        return { row: 'none', why: 'grant_binding' };
+    const tool = ownData(card, 'toolName');
+    if (typeof tool !== 'string' || tool.length === 0)
+        return { row: 'none', why: 'tool_name_unreadable' };
+    if (automaticAnswerVerdict(card, 'standing_rule').kind !== 'may_answer')
+        return { row: 'none', why: 'rule_cannot_clear' };
+    if (typeof host !== 'object' || host === null)
+        return { row: 'none', why: 'host_fact_missing' };
+    const face = ownData(host, 'cardFace');
+    if (typeof face !== 'string')
+        return { row: 'none', why: 'host_fact_missing' };
+    if (face !== 'generic')
+        return { row: 'none', why: 'face_not_generic' };
+    const sent = ownData(host, 'wholeToolRuleSent');
+    if (typeof sent !== 'boolean')
+        return { row: 'none', why: 'host_fact_missing' };
+    if (!sent)
+        return { row: 'none', why: 'rule_not_sent' };
+    return { row: 'local_whole_tool', why: 'given' };
+}
+function enginePremiseOf(card) {
+    const refused = present(card, 'rememberRefused');
+    if (refused === UNREADABLE)
+        return 'card_unreadable';
+    if (refused.inCard)
+        return refused.value === true ? 'remember_refused' : 'remember_unreadable';
+    const evidence = present(card, 'unreadableEvidence');
+    if (evidence === UNREADABLE)
+        return 'card_unreadable';
+    if (!evidence.inCard)
+        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 };
+}
+export function standingRowsOf(card, host) {
+    if (typeof card !== 'object' || card === null)
+        return allClosed('card_unreadable');
+    try {
+        const premise = enginePremiseOf(card);
+        if (typeof premise === 'string')
+            return allClosed(premise);
+        const evidenceUnreadable = premise.evidenceUnreadable;
+        const sessionRow = ownData(card, 'allowSessionCarried') === true;
+        const sessionWhy = sessionRow ? 'given' : 'route_cannot_carry';
+        let deploymentList;
+        if (!sessionRow) {
+            deploymentList = 'route_cannot_carry';
+        }
+        else {
+            const pair = readAskClassPairState(card);
+            deploymentList =
+                pair.state !== 'pair'
+                    ? 'classes_unreadable'
+                    : pair.classes.every((c) => DEPLOYMENT_LIST_ASK_CLASSES.includes(c))
+                        ? 'given'
+                        : 'not_deployment_list_question';
+        }
+        const persistent = persistentRowOf(card, host, evidenceUnreadable);
+        if (persistent === UNREADABLE)
+            return allClosed('card_unreadable');
+        return freezeRows(sessionRow, persistent.row, deploymentList === 'given', { session: sessionWhy, persistent: persistent.why, deploymentList });
+    }
+    catch {
+        return allClosed('card_unreadable');
+    }
+}
+export function seatSessionRowOf(card, requestId) {
+    if (typeof card !== 'object' || card === null)
+        return false;
+    try {
+        if (Object.hasOwn(card, 'requestId'))
+            return false;
+        const domain = toolPermissionRequestIdDomain(requestId);
+        if (domain !== 'live:' && domain !== 'durable:')
+            return false;
+        return typeof enginePremiseOf(card) !== 'string';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hitl/suspendedReopen.js

@@ -1,4 +1,5 @@
 import { RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { guardedRead, ownDataField } from '../ownKey.js';
 const UNSTATED = Object.freeze({ kind: 'unstated' });
 const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
 export function suspendedReopenOf(ev) {
@@ -22,7 +23,7 @@ export function suspendedReopenOf(ev) {
 export function resumeReopenFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    const code = err.errorCode;
+    const code = guardedRead(() => ownDataField(err, 'errorCode'));
     if (typeof code !== 'string' || !RESUME_REOPEN_CODES.includes(code))
         return null;
     if (!refusalSaysStillPending(err))

package/dist/hitl/toolApprovalWire.d.ts

@@ -6,11 +6,7 @@ import { type DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
 import { type ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecideReceiptView } from '../decideReceipt.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, ApprovalSettleCause, ToolApprovalRespondAck, PersistedRuleAnchor as SdkPersistedRuleAnchor, RuleOfferMatch as SdkRuleOfferMatch, RuleOfferBatchMember as SdkRuleOfferBatchMember, RuleOfferUncoveredDetail as SdkRuleOfferUncoveredDetail, RuleOfferUncoveredReason as SdkRuleOfferUncoveredReason, AskOrigin as SdkAskOrigin, RuleOffersAbsence as SdkRuleOffersAbsence, DenialLimitKind as SdkDenialLimitKind, DenialLimitFallback as SdkDenialLimitFallback } from '@sema-agent/sdk';
-export declare function isFsApprovalGate(gate: {
-    kind?: unknown;
-    toolName?: unknown;
-} | undefined | null): boolean;
+import type { ApprovalDecidedBy, ApprovalSettleCause, ToolApprovalRespondAck, PersistedRuleAnchor as SdkPersistedRuleAnchor, RuleOfferMatch as SdkRuleOfferMatch, RuleOfferBatchMember as SdkRuleOfferBatchMember, RuleOfferUncoveredDetail as SdkRuleOfferUncoveredDetail, RuleOfferUncoveredReason as SdkRuleOfferUncoveredReason, AskOrigin as SdkAskOrigin, RuleOffersAbsence as SdkRuleOffersAbsence, DenialLimitKind as SdkDenialLimitKind, DenialLimitFallback as SdkDenialLimitFallback, ToolApprovalCardWord } from '@sema-agent/sdk';
 export declare function toolNameIsFsWrite(name: string): boolean;
 export declare function toolNameIsShellExec(name: string): boolean;
 export declare function isToolApprovalGate(gate: {
@@ -40,8 +36,9 @@ export type FsApprovalOutcome = {
     stage: HitlFailureStage;
     gatedCallId?: string | undefined;
     reason: string;
-    code?: 'no_pending' | undefined;
+    code?: 'no_pending' | 'wrong_gate' | undefined;
     errorCode?: string | undefined;
+    blockedBy?: string | undefined;
     retriable?: true;
     safetyCode?: HitlSafetyCode | undefined;
     retryExhausted?: true;
@@ -68,7 +65,6 @@ export type DenialLimitKind = SdkDenialLimitKind;
 export type DenialLimitFallback = SdkDenialLimitFallback;
 export { RULE_OFFERS_ABSENCE_REASONS };
 export declare const ASK_ORIGIN_WORDS: readonly string[];
-export declare const APPROVAL_MANDATE_WORDS: readonly ["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "write_protection_unresolved"];
 export type WireRuleOffer = {
     kind: 'single';
     rule: string;
@@ -141,6 +137,7 @@ export interface ApprovalCardRequest {
     probeCause?: unknown;
     probeReason?: string;
     rememberRefused?: true;
+    allowSessionCarried?: true;
     ruleEvidence?: unknown;
     requiresRealApproval?: true;
     irreversibleParkGate?: true;
@@ -154,9 +151,12 @@ export interface ApprovalCardRequest {
     mandate?: ApprovalMandateWord;
     denialLimitFallback?: DenialLimitFallback;
     origin?: string;
+    approvalCard?: ToolApprovalCardWord;
     askClass?: string;
     classes?: readonly string[];
     boundGrants?: BoundSkillGrantsWire;
+    grantBinding?: ApprovalGrantBinding;
+    unreadableEvidence?: readonly string[];
     classifierNoRuling?: string;
     priorCardsForCall?: readonly ApprovalPriorCard[];
 }
@@ -174,12 +174,13 @@ export declare function approvalCardPortMissesFor(sessionKey: string): number;
 export declare function hasApprovalCardPort(): boolean;
 export declare function hasApprovalCardPortFor(sessionKey: string): boolean;
 export declare function approvalCardPortFor(sessionKey: string): ApprovalCardPort | null;
+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", "remember_requires_binding", "capability.store_required", "decide.workflow_remember_unsupported", "decide.parked_remember_unsupported"];
 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): Promise<FsApprovalOutcome>;
+export declare function surfaceFsApprovalAndDecide(deps: FsApprovalWireDeps, taskId: string, argsByCall: Map<string, unknown>, signal?: AbortSignal, parkGatedCallId?: string, parkToolName?: string): Promise<FsApprovalOutcome>;
 export interface BoundSkillGrantsWire {
     readonly skill: string | null;
     readonly allowedTools: readonly string[];
@@ -216,6 +217,7 @@ export interface ToolApprovalFrame {
     mandated?: true;
     mandate?: string;
     origin?: string;
+    approvalCard?: string;
     askClass?: string;
     classes?: readonly string[];
     inputHasBidi?: true;
@@ -235,7 +237,7 @@ export interface ToolApprovalDelegation {
     depth: number;
     agentName?: string;
 }
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "approvalCard", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause"];
 export interface ApprovalMandatedFacts {
     readonly mandated?: true;
     readonly ruleOffersAbsence?: string;
@@ -245,7 +247,8 @@ export declare function approvalIsMandated(v: ApprovalMandatedFacts | undefined
 export declare function readApprovalMandate(v: {
     readonly mandate?: string;
 } | undefined | null): ApprovalMandateWord | undefined;
-export declare function toolPermissionRequestAskBits(card: object | null | undefined): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence' | 'askClass' | 'classes'>;
+export declare function readApprovalCardWord(carrier: unknown): ToolApprovalCardWord | undefined;
+export declare function toolPermissionRequestAskBits(card: object | null | undefined, requestId?: string): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence' | 'askClass' | 'classes' | 'sessionRow'>;
 export declare function isFromSubagent(frame: ToolApprovalFrame): boolean;
 export type ToolApprovalRespondDecision = 'allow' | 'allow_session' | 'deny';
 export interface RespondToolApprovalOpts {
@@ -299,6 +302,12 @@ interface ToolApprovalRespondRefusalFields {
     status?: number;
     errorCode?: string;
     message?: string;
+    retriable?: true;
+    extra?: {
+        readonly cause?: string;
+        readonly field?: string;
+    };
+    unreadable?: true;
 }
 export type ToolApprovalRespondRefusal = (ToolApprovalRespondRefusalFields & {
     status: number;
@@ -312,6 +321,7 @@ export declare function isToolApprovalFrame(ev: unknown): ev is ToolApprovalFram
 export declare function askProbeReasonDetail(card: Pick<ApprovalCardRequest, 'probeReason' | 'probeCause'> | null | undefined): string | undefined;
 export declare function readApprovalRememberRefused(v: unknown): boolean;
 export declare function readApprovalBoundGrants(v: unknown): BoundSkillGrantsWire | undefined;
+export type ApprovalGrantBinding = 'bound' | 'none' | 'unreadable';
 export declare function readApprovalClassifierNoRuling(v: unknown): string | undefined;
 export declare function classifierNoRulingDetail(word: string | undefined): string;
 export declare function approvalBoundGrantsDetail(grants: BoundSkillGrantsWire | null | undefined): string | undefined;
@@ -319,6 +329,8 @@ export declare function approvalPriorCardsDetail(card: Pick<ApprovalCardRequest,
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOffer[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOffer[] | 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'>;
+export declare function approvalCardFactsOfV1(card: object | null | undefined): Readonly<ApprovalCardV1Facts> | undefined;
 export interface ToolApprovalFrameLaneOpts {
     approvalDecisionNoteCapable?: boolean;
     respondFreeFormRulesCapable?: boolean;