@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/hitl/screenDecisionCards.js

@@ -0,0 +1,362 @@
+import { SCREEN_CARD_ORIGINS } from './gateIdentity.js';
+import { convergeEndedEngineGeneration, } from '../engineGenerationConvergence.js';
+import { checkpointRowVerdictOf } from '../checkpointRowVerdict.js';
+import { planReviewCardFactsFrom } from '../planReviewCardFacts.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { PARK_GATE_KEY } from './screenCardCarriers.js';
+import { pendingRowAnswersCall } from './hitlBridge.js';
+import { cardIsOnParkRow } from './toolApprovalWire.js';
+export const SCREEN_CARD_KEEP_REASONS = Object.freeze(['not-ready', 'generation-moved', 'not-withdrawable', 'no-gate', 'not-early', 'no-row', 'not-owned', 'verdict-ok', 'verdict-absent']);
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+const finite = (v) => typeof v === 'number' && Number.isFinite(v);
+const ORIGIN_SET = new Set(SCREEN_CARD_ORIGINS);
+const PACKAGE_WITHDRAWABLE = new Set(['park-approval', 'park-question', 'plan-review', 'host-reopen-question']);
+const NOT_ENGINE_DECISION = new Set(['host-choice', 'local-permission']);
+function own(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' ? r.value : undefined;
+}
+function originOf(v) {
+    return typeof v === 'string' && ORIGIN_SET.has(v) ? v : undefined;
+}
+function toolGateOf(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    const taskId = own(v, 'taskId');
+    const gatedCallId = own(v, 'gatedCallId');
+    return nonEmpty(taskId) && nonEmpty(gatedCallId) ? Object.freeze({ kind: 'tool', taskId, gatedCallId }) : undefined;
+}
+export function questionFrameGateOf(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return undefined;
+        const park = slotReadOf(frame, PARK_GATE_KEY);
+        const plan = slotReadOf(frame, '_sema_planReview');
+        if (park.presence === 'unreadable' || plan.presence === 'unreadable')
+            return undefined;
+        const hasPark = park.presence === 'present' && park.value !== undefined;
+        const hasPlan = plan.presence === 'present' && plan.value !== undefined;
+        if (hasPark && hasPlan)
+            return undefined;
+        if (hasPark)
+            return toolGateOf(park.value);
+        if (!hasPlan)
+            return undefined;
+        const facts = planReviewCardFactsFrom(plan.value);
+        if (facts === undefined)
+            return undefined;
+        return Object.freeze({ kind: 'plan', taskId: facts.taskId, ...(facts.checkpointId !== undefined ? { checkpointId: facts.checkpointId } : {}) });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalCardGateOf(card) {
+    try {
+        if (typeof card !== 'object' || card === null || !cardIsOnParkRow(card))
+            return undefined;
+        const taskId = own(card, 'taskId');
+        const park = own(card, 'parkRow');
+        if (!nonEmpty(taskId) || typeof park !== 'object' || park === null)
+            return undefined;
+        const gatedCallId = own(park, 'gatedCallId');
+        return nonEmpty(gatedCallId) ? Object.freeze({ kind: 'tool', taskId, gatedCallId }) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalCardOriginOf(card) {
+    try {
+        return cardIsOnParkRow(card) ? 'park-approval' : 'live-approval';
+    }
+    catch {
+        return 'live-approval';
+    }
+}
+export function screenCardsHoldEngineDecision(cards) {
+    return engineDecisionReadingOf(cards) !== 'none';
+}
+function engineDecisionReadingOf(cards) {
+    try {
+        if (!Array.isArray(cards))
+            return 'none';
+        const len = own(cards, 'length');
+        if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0)
+            return 'unreadable';
+        for (let i = 0; i < len; i++) {
+            const card = own(cards, String(i));
+            const origin = typeof card === 'object' && card !== null ? originOf(own(card, 'origin')) : undefined;
+            if (origin === undefined || !NOT_ENGINE_DECISION.has(origin))
+                return 'holds';
+        }
+        return 'none';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function cardReadingOf(card) {
+    try {
+        if (typeof card !== 'object' || card === null)
+            return undefined;
+        const instance = own(card, 'instance');
+        if (!nonEmpty(instance))
+            return undefined;
+        return {
+            instance,
+            origin: originOf(own(card, 'origin')),
+            gate: own(card, 'gate'),
+            sourceGeneration: own(card, 'sourceGeneration'),
+            toolCallId: own(card, 'toolCallId'),
+            window: own(card, 'window'),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function distinctCards(cards) {
+    if (!Array.isArray(cards))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const card of cards) {
+        const r = cardReadingOf(card);
+        if (r === undefined || seen.has(r.instance))
+            continue;
+        seen.add(r.instance);
+        out.push(r);
+    }
+    return out;
+}
+function usableGateOf(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    const kind = own(v, 'kind');
+    const taskId = own(v, 'taskId');
+    if (!nonEmpty(taskId))
+        return undefined;
+    if (kind === 'tool') {
+        const gatedCallId = own(v, 'gatedCallId');
+        return nonEmpty(gatedCallId) ? { kind: 'tool', taskId, gatedCallId } : undefined;
+    }
+    if (kind === 'plan') {
+        const checkpointId = own(v, 'checkpointId');
+        return nonEmpty(checkpointId) ? { kind: 'plan', taskId, checkpointId } : undefined;
+    }
+    return undefined;
+}
+function withdrawableSetOf(v) {
+    const out = new Set();
+    if (!Array.isArray(v))
+        return out;
+    for (const o of v) {
+        const origin = originOf(o);
+        if (origin !== undefined && PACKAGE_WITHDRAWABLE.has(origin))
+            out.add(origin);
+    }
+    return out;
+}
+function candidacyOf(card, generation, cap) {
+    if (card.origin === undefined || !cap.has(card.origin))
+        return { ok: false, why: 'not-withdrawable' };
+    const gate = usableGateOf(card.gate);
+    if (gate === undefined)
+        return { ok: false, why: 'no-gate' };
+    if (finite(card.sourceGeneration) && card.sourceGeneration >= generation)
+        return { ok: false, why: 'not-early' };
+    return { ok: true, origin: card.origin, gate };
+}
+function rowAnswersGate(row, gate) {
+    const r = row;
+    if (gate.kind === 'tool')
+        return pendingRowAnswersCall(r, gate.taskId, gate.gatedCallId);
+    return r.taskId === gate.taskId && r.checkpointId === gate.checkpointId;
+}
+function ownedSafely(isOwned, row) {
+    try {
+        return isOwned(row) === true;
+    }
+    catch {
+        return false;
+    }
+}
+const EMPTY_ENDED = Object.freeze({ phase: 'ended', retract: Object.freeze([]), phases: Object.freeze([]) });
+const EMPTY_READY = Object.freeze({ phase: 'ready', withdraw: Object.freeze([]), keep: Object.freeze([]) });
+function endedPlanOf(facts) {
+    const cards = distinctCards(own(facts, 'cards')).map((c) => {
+        const w = c.window;
+        const leftMs = typeof w === 'object' && w !== null ? own(w, 'leftMs') : undefined;
+        const closedByEngine = typeof w === 'object' && w !== null ? own(w, 'closedByEngine') : undefined;
+        return {
+            callKey: c.instance,
+            parkRow: c.origin !== 'live-approval',
+            ...(nonEmpty(c.toolCallId) ? { toolCallId: c.toolCallId } : {}),
+            ...(finite(leftMs) ? { windowLeftMs: leftMs } : {}),
+            ...(closedByEngine === true ? { closedByEngine: true } : {}),
+        };
+    });
+    const opened = own(facts, 'opened');
+    const phases = own(facts, 'phases');
+    const endedGeneration = own(facts, 'endedGeneration');
+    const plan = convergeEndedEngineGeneration({
+        cards,
+        opened: Array.isArray(opened) ? opened : [],
+        ...(Array.isArray(phases) ? { phases: phases } : {}),
+        endedGeneration: finite(endedGeneration) ? endedGeneration : Number.NaN,
+    });
+    return Object.freeze({ phase: 'ended', retract: plan.retract, phases: plan.phases });
+}
+function readyPlanOf(facts) {
+    const cards = distinctCards(own(facts, 'cards'));
+    const generation = own(facts, 'generation');
+    const keep = [];
+    const withdraw = [];
+    const keepAll = (why) => Object.freeze({ phase: 'ready', withdraw: Object.freeze([]), keep: Object.freeze(cards.map((c) => Object.freeze({ instance: c.instance, why }))) });
+    if (own(facts, 'ready') !== true || !finite(generation))
+        return keepAll('not-ready');
+    if (own(facts, 'readGeneration') !== generation)
+        return keepAll('generation-moved');
+    const cap = withdrawableSetOf(own(facts, 'withdrawable'));
+    const rowsRaw = own(facts, 'rows');
+    const rows = Array.isArray(rowsRaw) ? rowsRaw.filter((r) => typeof r === 'object' && r !== null) : [];
+    const isOwnedRaw = own(facts, 'isOwned');
+    const isOwned = typeof isOwnedRaw === 'function' ? isOwnedRaw : () => false;
+    for (const card of cards) {
+        const c = candidacyOf(card, generation, cap);
+        if (!c.ok) {
+            keep.push(Object.freeze({ instance: card.instance, why: c.why }));
+            continue;
+        }
+        const matched = rows.filter((r) => rowAnswersGate(r, c.gate));
+        if (matched.length === 0) {
+            keep.push(Object.freeze({ instance: card.instance, why: 'no-row' }));
+            continue;
+        }
+        const row = matched.find((r) => ownedSafely(isOwned, r));
+        if (row === undefined) {
+            keep.push(Object.freeze({ instance: card.instance, why: 'not-owned' }));
+            continue;
+        }
+        const verdict = checkpointRowVerdictOf(row);
+        if (verdict === undefined) {
+            keep.push(Object.freeze({ instance: card.instance, why: 'verdict-absent' }));
+            continue;
+        }
+        if (verdict.kind === 'ok') {
+            keep.push(Object.freeze({ instance: card.instance, why: 'verdict-ok' }));
+            continue;
+        }
+        const rowVerdict = verdict;
+        withdraw.push(Object.freeze({ instance: card.instance, origin: c.origin, row, withdrawal: Object.freeze({ toldBy: 'host', rowVerdict }) }));
+    }
+    return Object.freeze({ phase: 'ready', withdraw: Object.freeze(withdraw), keep: Object.freeze(keep) });
+}
+export function engineGenerationCardPlan(facts) {
+    let phase;
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return EMPTY_READY;
+        phase = own(facts, 'phase');
+        if (phase === 'ended')
+            return endedPlanOf(facts);
+        if (phase === 'ready')
+            return readyPlanOf(facts);
+        return EMPTY_READY;
+    }
+    catch {
+        return (phase === 'ended' ? EMPTY_ENDED : EMPTY_READY);
+    }
+}
+export function engineGenerationCardRecheckDue(facts) {
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return false;
+        const generation = own(facts, 'generation');
+        if (own(facts, 'ready') !== true || !finite(generation))
+            return false;
+        const cap = withdrawableSetOf(own(facts, 'withdrawable'));
+        return distinctCards(own(facts, 'cards')).some((c) => candidacyOf(c, generation, cap).ok);
+    }
+    catch {
+        return false;
+    }
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null && !Object.isFrozen(v)) {
+        Object.freeze(v);
+        for (const k of Object.keys(v))
+            deepFreeze(v[k]);
+    }
+    return v;
+}
+const GOLD_LACKING = { kind: 'lacking', code: 'checkpoint.unsupported_version', reason: 'version_newer', sentence: 'Newer engine.' };
+const GOLD_DAMAGED = { kind: 'damaged', code: 'checkpoint.invalid_outcome', reason: 'requirements_damaged', sentence: 'Row damaged.' };
+function goldenCases() {
+    const ALL = ['park-approval', 'park-question', 'plan-review', 'host-reopen-question'];
+    const ready = (name, cards, rows, pick, over = {}) => {
+        const facts = { phase: 'ready', generation: 2, ready: true, readGeneration: 2, cards, rows, withdrawable: ALL, ...over };
+        return { name, facts, plan: { phase: 'ready', ...pick(facts.rows) } };
+    };
+    const tool = (taskId, gatedCallId) => ({ kind: 'tool', taskId, gatedCallId });
+    const W = (instance, origin, row, rowVerdict) => ({ instance, origin, row, withdrawal: { toldBy: 'host', rowVerdict } });
+    const K = (instance, why) => ({ instance, why });
+    const lacking = GOLD_LACKING;
+    const damaged = GOLD_DAMAGED;
+    const cases = [
+        {
+            name: 'ended-live-window-open-only',
+            facts: {
+                phase: 'ended',
+                endedGeneration: 1,
+                cards: [
+                    { instance: 'live-open', origin: 'live-approval', toolCallId: 'call-1', window: { leftMs: 60_000 } },
+                    { instance: 'live-margin', origin: 'live-approval', toolCallId: 'call-2', window: { leftMs: 5_000 } },
+                    { instance: 'live-closed', origin: 'live-approval', toolCallId: 'call-3', window: { leftMs: 60_000, closedByEngine: true } },
+                    { instance: 'live-no-window', origin: 'live-approval', toolCallId: 'call-4' },
+                    { instance: 'parked', origin: 'park-approval', toolCallId: 'call-5', window: { leftMs: 60_000 } },
+                    { instance: 'no-origin', toolCallId: 'call-6', window: { leftMs: 60_000 } },
+                ],
+                opened: [{ toolCallId: 'call-7', generation: 1 }, { toolCallId: 'call-8', generation: 0 }],
+            },
+            plan: { phase: 'ended', retract: ['live-open'], phases: [{ toolCallId: 'call-1', phase: 'engine-stopped-awaiting-approval', viaCallKey: 'live-open' }, { toolCallId: 'call-7', phase: 'engine-stopped-before-result' }] },
+        },
+        {
+            name: 'ended-live-without-call-id',
+            facts: { phase: 'ended', endedGeneration: 3, cards: [{ instance: 'live', origin: 'live-approval', window: { leftMs: 9_000 } }], opened: [] },
+            plan: { phase: 'ended', retract: ['live'], phases: [] },
+        },
+        ready('ready-park-question-withdrawn', [{ instance: 'q', origin: 'park-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 }], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }], (rows) => ({ withdraw: [W('q', 'park-question', rows[0], lacking)], keep: [] })),
+        ready('ready-bound-call-id-matches', [{ instance: 'a', origin: 'park-approval', gate: tool('run-2', 'call-2'), sourceGeneration: 1 }], [{ taskId: 'run-2', toolCallId: 'call-x', boundCallId: 'call-2', rowVerdict: GOLD_DAMAGED, owned: true }], (rows) => ({ withdraw: [W('a', 'park-approval', rows[0], damaged)], keep: [] })),
+        ready('ready-plan-by-checkpoint', [
+            { instance: 'plan-same', origin: 'plan-review', gate: { kind: 'plan', taskId: 'run-3', checkpointId: 'cp-1' } },
+            { instance: 'plan-moved', origin: 'plan-review', gate: { kind: 'plan', taskId: 'run-4', checkpointId: 'cp-old' }, sourceGeneration: 1 },
+            { instance: 'plan-no-checkpoint', origin: 'plan-review', gate: { kind: 'plan', taskId: 'run-5' }, sourceGeneration: 1 },
+        ], [{ taskId: 'run-3', checkpointId: 'cp-1', rowVerdict: GOLD_LACKING, owned: true }, { taskId: 'run-4', checkpointId: 'cp-new', rowVerdict: GOLD_LACKING, owned: true }, { taskId: 'run-5', checkpointId: 'cp-5', rowVerdict: GOLD_LACKING, owned: true }], (rows) => ({ withdraw: [W('plan-same', 'plan-review', rows[0], lacking)], keep: [K('plan-moved', 'no-row'), K('plan-no-checkpoint', 'no-gate')] })),
+        ready('ready-kinds-never-withdrawn', [
+            { instance: 'live', origin: 'live-approval', gate: tool('run-1', 'call-1'), sourceGeneration: 1 },
+            { instance: 'choice', origin: 'host-choice', gate: tool('run-1', 'call-1'), sourceGeneration: 1 },
+            { instance: 'unnamed', gate: tool('run-1', 'call-1'), sourceGeneration: 1 },
+            { instance: 'reopened', origin: 'host-reopen-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 },
+        ], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }], (rows) => ({ withdraw: [W('reopened', 'host-reopen-question', rows[0], lacking)], keep: [K('live', 'not-withdrawable'), K('choice', 'not-withdrawable'), K('unnamed', 'not-withdrawable')] })),
+        ready('ready-host-withdrawable-only', [{ instance: 'q', origin: 'park-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 }, { instance: 'r', origin: 'host-reopen-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 }], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }], (rows) => ({ withdraw: [W('r', 'host-reopen-question', rows[0], lacking)], keep: [K('q', 'not-withdrawable')] }), { withdrawable: ['host-reopen-question'] }),
+        ready('ready-current-generation-kept', [{ instance: 'q', origin: 'park-question', gate: tool('run-1', 'call-1'), sourceGeneration: 2 }], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }], () => ({ withdraw: [], keep: [K('q', 'not-early')] })),
+        ready('ready-keep-reasons', [
+            { instance: 'no-gate', origin: 'park-question', sourceGeneration: 1 },
+            { instance: 'no-row', origin: 'park-question', gate: tool('run-9', 'call-9'), sourceGeneration: 1 },
+            { instance: 'foreign', origin: 'park-question', gate: tool('run-7', 'call-7'), sourceGeneration: 1 },
+            { instance: 'fine', origin: 'park-question', gate: tool('run-8', 'call-8'), sourceGeneration: 1 },
+            { instance: 'no-verdict', origin: 'park-question', gate: tool('run-6', 'call-6'), sourceGeneration: 1 },
+        ], [
+            { taskId: 'run-7', toolCallId: 'call-7', rowVerdict: GOLD_LACKING, owned: false },
+            { taskId: 'run-8', toolCallId: 'call-8', rowVerdict: { kind: 'ok' }, owned: true },
+            { taskId: 'run-6', toolCallId: 'call-6', owned: true },
+        ], () => ({ withdraw: [], keep: [K('no-gate', 'no-gate'), K('no-row', 'no-row'), K('foreign', 'not-owned'), K('fine', 'verdict-ok'), K('no-verdict', 'verdict-absent')] })),
+        ready('ready-not-ready', [{ instance: 'q', origin: 'park-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 }], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }], () => ({ withdraw: [], keep: [K('q', 'not-ready')] }), { ready: false }),
+        ready('ready-generation-moved', [{ instance: 'q', origin: 'park-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 }], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }], () => ({ withdraw: [], keep: [K('q', 'generation-moved')] }), { readGeneration: 1 }),
+        ready('ready-instance-judged-once', [{ instance: 'q', origin: 'park-question', gate: tool('run-8', 'call-8'), sourceGeneration: 1 }, { instance: 'q', origin: 'park-question', gate: tool('run-1', 'call-1'), sourceGeneration: 1 }], [{ taskId: 'run-1', toolCallId: 'call-1', rowVerdict: GOLD_LACKING, owned: true }, { taskId: 'run-8', toolCallId: 'call-8', rowVerdict: { kind: 'ok' }, owned: true }], () => ({ withdraw: [], keep: [K('q', 'verdict-ok')] })),
+    ];
+    return deepFreeze(cases);
+}
+export const ENGINE_GENERATION_CARD_PLAN_GOLDEN = goldenCases();

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 LocalAllowOfferedFacts } 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,7 @@ export interface StandingRows {
 }
 export interface StandingRowsHostFacts {
     readonly wholeToolRuleSent?: boolean;
+    readonly readOnlyRedemption?: LocalAllowOfferedFacts;
 }
 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

@@ -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 { 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');
@@ -186,6 +202,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) {

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;