@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/hitl/sessionPolicyWire.js

@@ -3,7 +3,7 @@ import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { hostLog } from '../host.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
-import { RULES_INERT_ENTRY, RULES_INVALID_SHAPE, isRulesRefusalCode } from '../engineErrorCodes.js';
+import { CORRUPT_ROW_ERROR_CODE, RULES_INERT_ENTRY, RULES_INVALID_SHAPE, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { deniedEntryToolName } from '../engineToolDirectory.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_RULE_TOOL_NAME_VERDICTS } from '../generated/engineFactTables.js';
@@ -64,7 +64,7 @@ export function classifySessionPolicyFailure(e) {
     }
     if (errorCode === 'loosen_forbidden')
         return { kind: 'loosen-forbidden', message };
-    if (errorCode === 'corrupt')
+    if (errorCode === CORRUPT_ROW_ERROR_CODE)
         return { kind: 'store-corrupt', message };
     if (errorCode === 'conflict')
         return { kind: 'cas-conflict', message };

package/dist/hitl/standingRows.d.ts

@@ -1,6 +1,7 @@
 import { type PermissionsKeptReason } from '../permissionsDeclaration.js';
 import type { PermissionsAllowGrantReading } from '../permissionsAllowGrantCapability.js';
-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' | 'card_face_absent' | 'face_not_generic' | 'rule_not_sent';
+import { type LocalAllowDeclaredFacts, type LocalAllowOfferedFacts, type LocalAllowRedeemability } from './localAllowRedemption.js';
+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' | 'card_face_absent' | 'face_not_generic' | 'rule_not_sent' | 'redemption_closed' | 'redemption_unknown';
 export type StandingPersistentRow = 'engine_offer' | 'local_whole_tool' | 'none';
 export interface StandingRowsWhy {
     readonly session: StandingRowWhy;
@@ -15,6 +16,8 @@ export interface StandingRows {
 }
 export interface StandingRowsHostFacts {
     readonly wholeToolRuleSent?: boolean;
+    readonly readOnlyRedemption?: LocalAllowOfferedFacts;
+    readonly wholeToolLanding?: LocalAllowDeclaredFacts;
 }
 export declare function standingRowsOf(card: object | null | undefined, host?: StandingRowsHostFacts | null): StandingRows;
 export declare function seatSessionRowOf(card: object | null | undefined, requestId: string | undefined): boolean;
@@ -29,6 +32,7 @@ export declare function rememberOfferable(card: object | null | undefined, host?
 export interface LocalAllowRuleEnforcement {
     readonly enforceable: boolean;
     readonly engine: 'sent' | 'kept' | 'unreadable';
+    readonly redemption: LocalAllowRedeemability;
     readonly keptReason?: PermissionsKeptReason;
 }
-export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading): LocalAllowRuleEnforcement;
+export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading, landing?: LocalAllowDeclaredFacts): LocalAllowRuleEnforcement;

package/dist/hitl/standingRows.js

@@ -6,6 +6,7 @@ import { inSlotReadOf, inValueOf } from '../wireFailureShape.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
 import { permissionsDeclarationReport } from '../permissionsDeclaration.js';
 import { readCardUnreadableEvidence, sessionAllowCardReadable, sessionAllowEligible } from './sessionAllowRoute.js';
+import { localAllowLandingRedeemability, localAllowRedeemability } from './localAllowRedemption.js';
 const UNREADABLE = Symbol('unreadable');
 function ownData(v, key) {
     try {
@@ -54,6 +55,21 @@ function persistentRowOf(card, host, evidenceUnreadable) {
         const offers = readRuleOffers(p.state === 'present' ? p.value : undefined);
         if (offers === undefined || offers.length === 0)
             return { row: 'none', why: 'offers_unreadable' };
+        if (key === 'ruleOffersReadOnly') {
+            const facts = typeof host === 'object' && host !== null ? ownData(host, 'readOnlyRedemption') : undefined;
+            if (typeof facts !== 'object' || facts === null)
+                return { row: 'none', why: 'redemption_unknown' };
+            const judged = localAllowRedeemability({
+                subject: 'offered',
+                managedRulesOnly: ownData(facts, 'managedRulesOnly'),
+                scopeRoot: ownData(facts, 'scopeRoot'),
+                road: ownData(facts, 'road'),
+            });
+            if (judged.kind === 'not_redeemable')
+                return { row: 'none', why: 'redemption_closed' };
+            if (judged.kind === 'unknown')
+                return { row: 'none', why: 'redemption_unknown' };
+        }
         return { row: 'engine_offer', why: 'given' };
     }
     const absence = present(card, 'ruleOffersAbsence');
@@ -87,6 +103,11 @@ function persistentRowOf(card, host, evidenceUnreadable) {
         return { row: 'none', why: 'host_fact_missing' };
     if (!sent)
         return { row: 'none', why: 'rule_not_sent' };
+    const judged = localAllowLandingRedeemability(tool, ownData(host, 'wholeToolLanding'));
+    if (judged.kind === 'not_redeemable')
+        return { row: 'none', why: 'redemption_closed' };
+    if (judged.kind === 'unknown')
+        return { row: 'none', why: 'redemption_unknown' };
     return { row: 'local_whole_tool', why: 'given' };
 }
 function enginePremiseOf(card) {
@@ -186,6 +207,8 @@ const SESSION_OFFER = Object.freeze({
     card_face_absent: 'unknown',
     face_not_generic: 'refused',
     rule_not_sent: 'refused',
+    redemption_closed: 'refused',
+    redemption_unknown: 'unknown',
 });
 const PERSISTENT_OFFER = Object.freeze({ ...SESSION_OFFER, remember_refused: 'unknown' });
 export function rememberOfferable(card, host) {
@@ -196,7 +219,7 @@ export function rememberOfferable(card, host) {
         deploymentList: SESSION_OFFER[rows.why.deploymentList],
     });
 }
-export function localAllowRuleEnforceable(rule, caps) {
+export function localAllowRuleEnforceable(rule, caps, landing) {
     let engine = 'unreadable';
     let keptReason;
     if (typeof rule === 'string' && rule.trim() !== '') {
@@ -216,9 +239,11 @@ export function localAllowRuleEnforceable(rule, caps) {
             engine = 'unreadable';
         }
     }
+    const redemption = localAllowLandingRedeemability(rule, landing);
     return Object.freeze({
-        enforceable: engine === 'sent',
+        enforceable: engine === 'sent' && redemption.kind === 'redeemable',
         engine,
+        redemption,
         ...(keptReason !== undefined ? { keptReason } : {}),
     });
 }

package/dist/hitl/toolApprovalWire.d.ts

@@ -29,6 +29,7 @@ export interface FsApprovalWireDeps {
     onPresented?: () => void;
     onDecideOperation?: DecideOperationObserver;
     approvalDecidedBy?: ApprovalDecidedByReading | undefined;
+    engineGeneration?: () => number;
 }
 export declare function structurallyEqual(a: unknown, b: unknown): boolean;
 export type { RuleOfferMatch };
@@ -101,6 +102,7 @@ export interface ApprovalCardRequest {
     callKey: string;
     toolCallId?: string;
     taskId?: string;
+    sourceGeneration?: number;
     signal?: AbortSignal;
     workerBadge?: {
         name: string;
@@ -158,7 +160,6 @@ export interface ApprovalCardSupersedes {
     readonly priorAnswerOutcome?: 'not_sent' | 'not_accepted' | 'unconfirmed';
 }
 export interface ApprovalCardParkRow {
-    readonly taskId: string;
     readonly gatedCallId?: string;
     readonly deadlineMs?: number;
 }
@@ -238,7 +239,8 @@ export declare function answerPayloadFor(answer: ApprovalCardDecision, lane: 'de
 export interface AnswerCarriage {
     readonly allowNote: 'model' | 'none';
 }
-export declare function answerCarriage(card: Pick<ApprovalCardRequest, 'callKey' | 'parkRow'> | null | undefined): AnswerCarriage;
+export declare function answerCarriage(card: Pick<ApprovalCardRequest, 'callKey' | 'parkRow' | 'taskId'> | null | undefined): AnswerCarriage;
+export declare function cardIsOnParkRow(card: object | null | undefined): boolean;
 export declare function allowNoteNotCarriedSentence(lang?: UiLanguage): string;
 export interface ApprovalAnswerCommitted {
     readonly callKey: string;
@@ -286,6 +288,25 @@ export type ToolApprovalParkingBodyReading = {
     readonly kind: 'claimed_unreadable';
 };
 export declare function readToolApprovalRespondParking(v: unknown): ToolApprovalParkingBodyReading | undefined;
+export type ReplayVerdict = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'replayed';
+    readonly firstDecision: 'allow' | 'deny';
+    readonly via: 'arm' | 'claim';
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function replayVerdictFrom(raw: {} | null | undefined, parsed: ToolApprovalRespondAckView | undefined, approvalId: string): ReplayVerdict;
+export type ToolApprovalReplayVerdict = {
+    readonly kind: 'not_replay';
+} | {
+    readonly kind: 'replayed';
+    readonly firstDecision: 'allow' | 'deny';
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function toolApprovalReplayVerdictOf(raw: {} | null | undefined, approvalId: string): ToolApprovalReplayVerdict;
 export declare function decisionAttributionKeyOf(reading: ApprovalDecidedByReading | undefined, denySettledBy: ApprovalDenySettledBy | undefined): {
     decidedBy: 'policy';
 } | {
@@ -317,6 +338,8 @@ export interface ApprovalCardFrameFactsOptions {
     readonly streamArgs?: object;
     readonly argsUnavailable?: true;
 }
+export type ApprovalCardHostBits = Readonly<Pick<ApprovalCardRequest, 'callKey' | 'taskId' | 'signal' | 'expiresInMs' | 'expiresAtMs' | 'serverNowMs' | 'receivedAtMs' | 'sourceGeneration'>>;
+export declare function approvalCardRequestOf(facts: Readonly<ApprovalCardFacts>, host: ApprovalCardHostBits): ApprovalCardRequest | undefined;
 export declare function approvalCardFactsOfV1(card: object | null | undefined): Readonly<ApprovalCardV1Facts> | undefined;
 export declare function approvalCardFactsOfV1Frame(frame: object | null | undefined): Readonly<ApprovalCardFacts> | undefined;
 export declare function approvalCardFactsOfFrame(frame: object | null | undefined, opts?: ApprovalCardFrameFactsOptions | null): Readonly<ApprovalCardFacts> | undefined;
@@ -329,14 +352,13 @@ export interface ToolApprovalFrameLaneOpts {
     windowIsCurrent?: boolean;
     argsUnavailable?: true;
 }
-export declare function surfaceToolApprovalFrameAndRespond(frame: ToolApprovalFrame | ApprovalRequestFrame, respond: RespondToolApprovalFn, streamArgs: unknown | undefined, signal?: AbortSignal, lane?: ToolApprovalFrameLaneOpts, run?: {
-    readonly taskId?: string;
-    readonly sessionId?: string;
-}): Promise<ApprovalResolution>;
-export declare function surfaceApprovalFrameWithId(frame: ToolApprovalFrame | ApprovalRequestFrame, approvalId: string, respond: RespondToolApprovalFn, streamArgs: Parameters<typeof surfaceToolApprovalFrameAndRespond>[2], signal: AbortSignal | undefined, lane: ToolApprovalFrameLaneOpts | undefined, run: {
+export interface ToolApprovalFrameRunBits {
     readonly taskId?: string;
     readonly sessionId?: string;
-} | undefined): Promise<ApprovalResolution>;
+    readonly sourceGeneration?: number;
+}
+export declare function surfaceToolApprovalFrameAndRespond(frame: ToolApprovalFrame | ApprovalRequestFrame, respond: RespondToolApprovalFn, streamArgs: unknown | undefined, signal?: AbortSignal, lane?: ToolApprovalFrameLaneOpts, run?: ToolApprovalFrameRunBits): Promise<ApprovalResolution>;
+export declare function surfaceApprovalFrameWithId(frame: ToolApprovalFrame | ApprovalRequestFrame, approvalId: string, respond: RespondToolApprovalFn, streamArgs: Parameters<typeof surfaceToolApprovalFrameAndRespond>[2], signal: AbortSignal | undefined, lane: ToolApprovalFrameLaneOpts | undefined, run: ToolApprovalFrameRunBits | undefined): Promise<ApprovalResolution>;
 export interface ApprovalHolderIdentity {
     readonly approvalId?: string;
     readonly taskId?: string;