@sema-agent/client-core 0.111.0 → 0.112.1

package/dist/hitl/planReviewWire.js

@@ -18,6 +18,7 @@ import { denyReasonForWire, isPlanReviewModeAfter } from './hitlBridge.js';
 import { freshPlanReviewQuestionId, planReviewQuestionId, REOPEN_ID_TAIL, taskIdFromPlanReviewQuestionId } from './gateIdentity.js';
 import { isPlanReviewPark, mintPlanReviewCardFacts, notePlanReviewCardIssued, pausedCheckpointIdOf, planReviewCardFactsFrom, planReviewFactsCurrent, registeredPlanReviewCardFacts, samePlanReviewCardFacts, unknownBody, _resetPlanReviewRunsForTest, } from '../planReviewCardFacts.js';
 import { planReviewAskAgainKey, planReviewCardNoteRef, planReviewDecisionReasonRef, planReviewUnreadableNoteRef, takePlanReviewFacts, _resetPlanReviewFactsFlightsForTest, } from './planReviewCard.js';
+import { planReviewOutcomeCauseOf } from '../planReviewOutcomeCause.js';
 import { EN_MESSAGES } from '../i18n/messages.en.js';
 import { msg, renderMessage, DATA_FACE_LANGUAGE } from '../i18n/translate.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
@@ -666,11 +667,34 @@ function noteEngineRefusedGate(id) {
         engineRefusedGateIds.delete(oldest.value);
     }
 }
+function wireGateOf(decision, gate) {
+    if (gate === undefined)
+        return undefined;
+    if (decision === 'approve')
+        return gate;
+    return engineRefusedGateIds.has(gate) ? undefined : gate;
+}
+function planReviewWireBodyOf(decision, reason, mode, gate) {
+    const withReason = reason !== undefined ? { reason } : {};
+    const withMode = mode !== undefined ? { permissionModeAfter: mode } : {};
+    if (decision === 'approve')
+        return gate === undefined ? undefined : Object.freeze({ decision, ...withReason, ...withMode, checkpointId: gate });
+    return Object.freeze({ decision, ...withReason, ...withMode, ...(gate !== undefined ? { checkpointId: gate } : {}) });
+}
 function planReviewDecisionReasonSegment(reason, card) {
     if (reason === undefined)
         return '';
     try {
-        return ` ${renderMessage(planReviewDecisionReasonRef(reason, card), DATA_FACE_LANGUAGE)}`;
+        const ref = planReviewDecisionReasonRef(reason, card);
+        return ref === undefined ? '' : ` ${renderMessage(ref, DATA_FACE_LANGUAGE)}`;
+    }
+    catch {
+        return '';
+    }
+}
+function planReviewSentWithoutGateSegment() {
+    try {
+        return ` ${renderMessage(msg('approval.planReview.decision.sentWithoutGateId'), DATA_FACE_LANGUAGE)}`;
     }
     catch {
         return '';
@@ -741,9 +765,17 @@ function askAgainReasonOf(card, opts) {
         return renderMessage(msg('approval.planReview.askAgain.unknown'), DATA_FACE_LANGUAGE);
     }
 }
+function planReviewDecisionWordOf(raw) {
+    return raw === 'approve' || raw === 'reject' || raw === 'ask_again' ? raw : undefined;
+}
 async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, card, cardId) {
+    const word = planReviewDecisionWordOf(decision);
+    if (word === undefined) {
+        hostLog('error', `planReviewWire: decision-word-refused typeof=${typeof decision}`);
+        return;
+    }
     if (typeof taskId === 'string' && planReviewOpsOf(taskId).some((op) => op.phase === 'posting')) {
-        hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
+        hostLog('error', `planReviewWire: decidePlanReview(${word}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
     }
     let op = typeof taskId === 'string' ? claimablePlanReviewDecisionOp(taskId) : undefined;
@@ -770,11 +802,11 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
         settleDecisionOp(mine, 'package');
     };
     const dispatchNo = ++decideDispatchSeq;
-    hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${decision} mode=${permissionModeAfter ?? '-'}`);
+    hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${word} mode=${permissionModeAfter ?? '-'}`);
     try {
-        const wireDecision = decision === 'ask_again' ? 'reject' : decision;
-        const wireOpts = decision === 'ask_again' ? { ...opts, reason: askAgainReasonOf(card, opts) } : opts;
-        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, decision, cardId);
+        const wireDecision = word === 'ask_again' ? 'reject' : word;
+        const wireOpts = word === 'ask_again' ? { ...opts, reason: askAgainReasonOf(card, opts) } : opts;
+        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, word, cardId);
     }
     finally {
         releaseLatch();
@@ -797,14 +829,15 @@ function planReviewClientsFor(resolved) {
 }
 async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, card, semanticDecision, cardId) {
     let outcome;
-    let decisionReason;
+    let cause;
+    let unsentProven = false;
     const gateBefore = card?.checkpointId;
     const approvalWithheld = decision !== 'approve' ? undefined : card === undefined ? 'card_missing' : card.body.kind !== 'shown' || card.checkpointId === undefined ? 'card_withholds' : undefined;
     let effect = 'unconfirmed';
-    let stillParkedCause;
     let statusSeen;
     const wire = opts?.wire;
     const resolved = engineWireFor(wire, DEFAULT_SESSION_KEY, usablePlanReviewWireClient);
+    const wireGate = wireGateOf(decision, gateBefore);
     const badMode = permissionModeAfter !== undefined && !isPlanReviewModeAfter(permissionModeAfter);
     if (badMode) {
         hostLog('error', `planReviewWire: ${decision} NOT sent — permissionModeAfter must be "default" or "acceptEdits"`);
@@ -814,7 +847,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
     else if (approvalWithheld !== undefined) {
         hostLog('debug', `planReviewWire: not-sent decision=${decision} reason=${approvalWithheld}`);
         effect = 'not_sent';
-        decisionReason = approvalWithheld;
+        cause = approvalWithheld;
         outcome = renderMessage(msg('approval.planReview.decision.notSent', { decision }), DATA_FACE_LANGUAGE);
     }
     else if (resolved.kind === 'no-target') {
@@ -836,7 +869,6 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         }
         else {
             const client = clients.decide;
-            const checkpointId = gateBefore !== undefined && !engineRefusedGateIds.has(gateBefore) ? gateBefore : undefined;
             const repullRow = async () => {
                 const probe = clients.repull();
                 if (!probe)
@@ -854,87 +886,90 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             try {
                 const mode = isPlanReviewModeAfter(permissionModeAfter) ? permissionModeAfter : undefined;
                 const reason = denyReasonForWire(opts?.reason, `plan-review ${taskId}`);
-                const reqBody = { decision };
-                if (reason !== undefined)
-                    reqBody.reason = reason;
-                if (mode !== undefined)
-                    reqBody.permissionModeAfter = mode;
-                if (checkpointId !== undefined)
-                    reqBody.checkpointId = checkpointId;
-                let body;
-                try {
-                    body = await sendOnce(undefined, () => client.assistant.planReview(taskId, reqBody));
+                const wireBody = planReviewWireBodyOf(decision, reason, mode, wireGate);
+                if (wireBody === undefined) {
+                    effect = 'not_sent';
+                    cause = 'card_withholds';
+                    outcome = renderMessage(msg('approval.planReview.decision.notSent', { decision }), DATA_FACE_LANGUAGE);
                 }
-                catch (e1) {
-                    const conflict = e1;
-                    const defaultConflict = mode === 'default' && conflict?.status === 400 && conflict?.errorCode === REQUEST_FIELD_CONFLICT;
-                    if (defaultConflict && !directFailureVerdictOf(e1, directSafetyStopOf(e1)).yields) {
-                        hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
-                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, { decision, ...(reason !== undefined ? { reason } : {}), ...(checkpointId !== undefined ? { checkpointId } : {}) }));
+                else {
+                    const firstSent = { ...wireBody };
+                    let body;
+                    try {
+                        body = await sendOnce(undefined, () => client.assistant.planReview(taskId, firstSent));
                     }
-                    else {
-                        throw e1;
+                    catch (e1) {
+                        const conflict = e1;
+                        const defaultConflict = mode === 'default' && conflict?.status === 400 && conflict?.errorCode === REQUEST_FIELD_CONFLICT;
+                        if (defaultConflict && !directFailureVerdictOf(e1, directSafetyStopOf(e1)).yields) {
+                            hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
+                            const { permissionModeAfter: _modeDropped, ...resend } = wireBody;
+                            body = await sendOnce(undefined, () => client.assistant.planReview(taskId, resend));
+                        }
+                        else {
+                            throw e1;
+                        }
                     }
-                }
-                finally {
-                    releaseLatch();
-                }
-                hostLog('debug', `planReviewWire: ${decision} → ok (dispatch #${dispatchNo}) ${JSON.stringify(body).slice(0, 200)}`);
-                let postStatus;
-                let gateAfter;
-                let gateKindAfter;
-                try {
-                    const post = await repullRow();
-                    if (post !== undefined) {
-                        postStatus = bodyWordOf(post, 'status');
-                        gateAfter = pausedCheckpointIdOf(post?.result);
-                        gateKindAfter = pausedGateKindOf(post?.result);
+                    finally {
+                        releaseLatch();
+                    }
+                    hostLog('debug', `planReviewWire: ${decision} → ok (dispatch #${dispatchNo}) ${JSON.stringify(body).slice(0, 200)}`);
+                    let postStatus;
+                    let gateAfter;
+                    let gateKindAfter;
+                    try {
+                        const post = await repullRow();
+                        if (post !== undefined) {
+                            postStatus = bodyWordOf(post, 'status');
+                            gateAfter = pausedCheckpointIdOf(post?.result);
+                            gateKindAfter = pausedGateKindOf(post?.result);
+                        }
+                    }
+                    catch (e) {
+                        hostLog('debug', `planReviewWire: post-decide status re-pull failed (fail-soft): ${String(e)}`);
+                    }
+                    const bodyStatus = bodyWordOf(body, 'status');
+                    const effective = postStatus ?? bodyStatus;
+                    statusSeen = effective;
+                    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 =
+                            `The plan_review ${decision} returned HTTP 200 but the session is STILL locked on the same review gate ` +
+                                `(post-decide status: needs_review). The decision did NOT take effect (known engine issue, RB-471 family). ` +
+                                `Tell the user plainly that the ${decision} did not go through; the reliable exits today are approving the plan or cancelling the task.`;
+                    }
+                    else if (effect === 'still_parked') {
+                        outcome =
+                            `The plan_review ${decision} was NOT applied: the engine could not continue the task and put the plan back to wait for a decision` +
+                                `${code !== undefined ? ` (engine code: ${code})` : ''}. Tell the user plainly that the ${decision} did not go through.`;
+                    }
+                    else if (effect === 'advanced') {
+                        outcome = planReviewAdvancedOutcome(decision, effective === 'needs_review' ? 'needs_review' : 'suspended');
+                    }
+                    else if (effect === 'took_effect') {
+                        outcome =
+                            `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')) {
+                        outcome =
+                            `The plan_review ${decision} returned HTTP 200 and the task is waiting at a plan review gate again (post-decide status: needs_review), ` +
+                                `but it could not be told whether this is the same review (the ${decision} did not take effect) or a new plan written after it (it did).`;
+                    }
+                    else if (effective === 'suspended' || effective === 'needs_review') {
+                        outcome =
+                            `The plan_review ${decision} was accepted by the engine (HTTP 200) and the task is paused again (post-decide status: ${effective}), ` +
+                                `${gateKindAfter !== undefined ? `at a '${gateKindAfter}' pause that is not an approval card` : 'but the pause it stopped at was not reported'} — what the ${decision} led to could not be confirmed.`;
+                    }
+                    else if (effective !== undefined) {
+                        outcome =
+                            `The plan_review ${decision} was accepted by the engine (HTTP 200), but the task then reported status ${effective}` +
+                                `${code !== undefined ? ` (engine code: ${code})` : ''} — not a completion; what the ${decision} led to could not be confirmed.`;
+                    }
+                    else {
+                        outcome = `The plan_review ${decision} was accepted by the engine (HTTP 200) but its effect is unconfirmed — final status: unknown (post-decide verification unavailable). Do not treat this as ${decision === 'approve' ? 'an approval that resumed the task' : 'a discarded plan'}.`;
                     }
-                }
-                catch (e) {
-                    hostLog('debug', `planReviewWire: post-decide status re-pull failed (fail-soft): ${String(e)}`);
-                }
-                const bodyStatus = bodyWordOf(body, 'status');
-                const effective = postStatus ?? bodyStatus;
-                statusSeen = effective;
-                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 =
-                        `The plan_review ${decision} returned HTTP 200 but the session is STILL locked on the same review gate ` +
-                            `(post-decide status: needs_review). The decision did NOT take effect (known engine issue, RB-471 family). ` +
-                            `Tell the user plainly that the ${decision} did not go through; the reliable exits today are approving the plan or cancelling the task.`;
-                }
-                else if (effect === 'still_parked') {
-                    outcome =
-                        `The plan_review ${decision} was NOT applied: the engine could not continue the task and put the plan back to wait for a decision` +
-                            `${code !== undefined ? ` (engine code: ${code})` : ''}. Tell the user plainly that the ${decision} did not go through.`;
-                }
-                else if (effect === 'advanced') {
-                    outcome = planReviewAdvancedOutcome(decision, effective === 'needs_review' ? 'needs_review' : 'suspended');
-                }
-                else if (effect === 'took_effect') {
-                    outcome =
-                        `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')) {
-                    outcome =
-                        `The plan_review ${decision} returned HTTP 200 and the task is waiting at a plan review gate again (post-decide status: needs_review), ` +
-                            `but it could not be told whether this is the same review (the ${decision} did not take effect) or a new plan written after it (it did).`;
-                }
-                else if (effective === 'suspended' || effective === 'needs_review') {
-                    outcome =
-                        `The plan_review ${decision} was accepted by the engine (HTTP 200) and the task is paused again (post-decide status: ${effective}), ` +
-                            `${gateKindAfter !== undefined ? `at a '${gateKindAfter}' pause that is not an approval card` : 'but the pause it stopped at was not reported'} — what the ${decision} led to could not be confirmed.`;
-                }
-                else if (effective !== undefined) {
-                    outcome =
-                        `The plan_review ${decision} was accepted by the engine (HTTP 200), but the task then reported status ${effective}` +
-                            `${code !== undefined ? ` (engine code: ${code})` : ''} — not a completion; what the ${decision} led to could not be confirmed.`;
-                }
-                else {
-                    outcome = `The plan_review ${decision} was accepted by the engine (HTTP 200) but its effect is unconfirmed — final status: unknown (post-decide verification unavailable). Do not treat this as ${decision === 'approve' ? 'an approval that resumed the task' : 'a discarded plan'}.`;
                 }
             }
             catch (e) {
@@ -960,7 +995,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 }
                 else if (status === 409 && refusedCode === APPROVAL_STALE) {
                     let untrusted = false;
-                    if (checkpointId !== undefined) {
+                    if (wireGate !== undefined) {
                         const bag = readThrownExtra(e);
                         const noCurrentPending = bag.state === 'object' &&
                             (() => {
@@ -974,25 +1009,25 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                         if (noCurrentPending) {
                             try {
                                 const row = await repullRow();
-                                untrusted = row !== undefined && pausedCheckpointIdOf(row?.result) === checkpointId;
+                                untrusted = row !== undefined && pausedCheckpointIdOf(row?.result) === wireGate;
                             }
                             catch {
                                 untrusted = false;
                             }
                         }
                     }
-                    if (untrusted && checkpointId !== undefined)
-                        noteEngineRefusedGate(checkpointId);
+                    if (untrusted && wireGate !== undefined)
+                        noteEngineRefusedGate(wireGate);
                     hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${untrusted ? 'gate_untrusted' : 'gate_moved'}`);
                     effect = 'not_applied';
-                    decisionReason = untrusted ? 'gate_untrusted' : 'gate_moved';
+                    cause = untrusted ? 'gate_untrusted' : 'gate_moved';
                     outcome = renderMessage(msg('approval.planReview.decision.refused', { decision }), DATA_FACE_LANGUAGE);
                 }
                 else if (checkpointUnsupportedVersionFromError(e) !== null) {
                     const cu = checkpointUnsupportedVersionFromError(e);
                     hostLog('debug', `planReviewWire: ${decision} → 409 checkpoint.unsupported_version (the server cannot continue this parked review in its stored form; still pending)`);
                     effect = 'still_parked';
-                    stillParkedCause = 'stored_form_unsupported';
+                    cause = 'stored_form_unsupported';
                     outcome = `This ${decision} was not applied. ${checkpointUnsupportedVersionContent(cu, { parkKind: 'plan_review', runId: taskId })}`;
                 }
                 else if (resumeContextUnavailableFromError(e) !== null) {
@@ -1024,18 +1059,20 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 else {
                     const failureTexts = wireFailureTextsOf(e);
                     hostLog('debug', `planReviewWire: ${decision} could not reach the engine: ${failureTexts.log}`);
+                    unsentProven = true;
                     outcome = `The plan_review decision could not reach the engine: ${failureTexts.reason}`;
                 }
             }
         }
     }
-    outcome = `${outcome}${planReviewDecisionReasonSegment(decisionReason, card)}`;
-    const tail = planReviewOutcomeTail(taskId, decision, effect, stillParkedCause);
+    const outcomeCause = planReviewOutcomeCauseOf(effect, cause);
+    outcome = `${outcome}${planReviewDecisionReasonSegment(outcomeCause, card)}${gateBefore !== undefined && wireGate === undefined && effect !== 'not_sent' && !unsentProven ? planReviewSentWithoutGateSegment() : ''}`;
+    const tail = planReviewOutcomeTail(taskId, decision, effect, outcomeCause);
     const prompt = `<plan-review-outcome>\n${outcome}\n${tail}\n</plan-review-outcome>`;
     const onOutcome = opts?.onOutcome;
     settle(effect === 'not_sent' || effect === 'still_parked');
     try {
-        const delivered = enqueuePlanReviewOutcome(prompt, { taskId, dispatchNo, decision: semanticDecision, effect, ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}), ...(cardId !== undefined ? { questionId: cardId } : {}) });
+        const delivered = enqueuePlanReviewOutcome(prompt, { taskId, dispatchNo, decision: semanticDecision, effect, ...(outcomeCause !== undefined ? { cause: outcomeCause } : {}), ...(cardId !== undefined ? { questionId: cardId } : {}) });
         if (!delivered) {
             if (onOutcome !== undefined) {
                 hostLog('debug', `planReviewWire: outcome queue port not installed for task ${taskId} — outcome handed to the host's onOutcome callback only`);
@@ -1054,7 +1091,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             dispatchNo,
             decision: semanticDecision,
             effect,
-            ...(effect === 'still_parked' && stillParkedCause !== undefined ? { cause: stillParkedCause } : {}),
+            ...(outcomeCause !== undefined ? { cause: outcomeCause } : {}),
             ...(cardId !== undefined ? { questionId: cardId } : {}),
             detail: outcome,
             tail,

package/dist/hitl/screenDecisionCards.js

@@ -1,6 +1,7 @@
 import { SCREEN_CARD_ORIGINS } from './gateIdentity.js';
 import { convergeEndedEngineGeneration, } from '../engineGenerationConvergence.js';
 import { checkpointRowVerdictOf } from '../checkpointRowVerdict.js';
+import { CHECKPOINT_INVALID_OUTCOME, CHECKPOINT_UNSUPPORTED_VERSION } from '../engineErrorCodes.js';
 import { planReviewCardFactsFrom } from '../planReviewCardFacts.js';
 import { slotReadOf } from '../wireFailureShape.js';
 import { PARK_GATE_KEY } from './screenCardCarriers.js';
@@ -291,8 +292,8 @@ function deepFreeze(v) {
     }
     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.' };
+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 = {}) => {

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,6 @@
 import { type PermissionsKeptReason } from '../permissionsDeclaration.js';
 import type { PermissionsAllowGrantReading } from '../permissionsAllowGrantCapability.js';
-import { type LocalAllowOfferedFacts } from './localAllowRedemption.js';
+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 {
@@ -17,6 +17,7 @@ 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;
@@ -31,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,7 +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';
+import { localAllowLandingRedeemability, localAllowRedeemability } from './localAllowRedemption.js';
 const UNREADABLE = Symbol('unreadable');
 function ownData(v, key) {
     try {
@@ -103,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) {
@@ -214,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() !== '') {
@@ -234,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/hooksReaderGenerations.js

@@ -1,6 +1,6 @@
 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']) }),
+    Object.freeze({ from: '7.139.0', below: '7.147.0', notRead: Object.freeze(['onFailure', 'rewakeMessage', 'rewakeSummary', 'cloud', 'continueOnBlock']) }),
 ]);
 const HOOKS_READER_FAIL_CLOSED = Object.freeze([...new Set(HOOKS_READER_GENERATIONS.flatMap((g) => g.notRead))]);
 export function hooksReaderNotReadKeys(serverVersion) {