@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/hitl/persistedRulesWire.js

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

package/dist/hitl/planReviewCard.d.ts

@@ -6,6 +6,8 @@ export declare function planReviewCardNoteRef(facts: PlanReviewCardFacts): Messa
 export declare function planReviewUnreadableNoteRef(): MessageRef;
 export declare function planReviewCardNote(facts: PlanReviewCardFacts, lang?: UiLanguage): string | undefined;
 export declare function planReviewAskAgainKey(facts: PlanReviewCardFacts | undefined): MessageKey;
+export type PlanReviewDecisionReason = 'card_missing' | 'card_withholds' | 'gate_moved' | 'gate_untrusted';
+export declare function planReviewDecisionReasonRef(reason: PlanReviewDecisionReason, card?: PlanReviewCardFacts): MessageRef;
 export interface PlanReviewLedgerSource {
     readonly runRow: (taskId: string, signal: AbortSignal) => Promise<object>;
     readonly frames: (taskId: string, signal: AbortSignal) => AsyncIterable<object>;

package/dist/hitl/planReviewCard.js

@@ -46,6 +46,27 @@ export function planReviewAskAgainKey(facts) {
             return body.cause === 'not_carried' ? 'approval.planReview.askAgain.notCarried' : 'approval.planReview.askAgain.unknown';
     }
 }
+export function planReviewDecisionReasonRef(reason, card) {
+    switch (reason) {
+        case 'card_missing':
+            return msg('approval.planReview.decision.cardMissing');
+        case 'card_withholds': {
+            let ref;
+            try {
+                const read = card === undefined ? undefined : planReviewCardFactsFrom(card);
+                ref = read === undefined ? undefined : planReviewCardNoteRef(read);
+            }
+            catch {
+                ref = undefined;
+            }
+            return ref ?? planReviewUnreadableNoteRef();
+        }
+        case 'gate_moved':
+            return msg('approval.planReview.decision.gateMoved');
+        case 'gate_untrusted':
+            return msg('approval.planReview.decision.gateUntrusted');
+    }
+}
 const PLAN_REVIEW_LEDGER_BUDGET_MS = 3_000;
 const planReviewFactsFlights = new Map();
 export function _resetPlanReviewFactsFlightsForTest() {

package/dist/hitl/planReviewWire.d.ts

@@ -100,7 +100,7 @@ export interface PlanReviewDeliveryOptions {
 }
 export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
     reason?: string;
-    parkedResult?: unknown;
+    card?: PlanReviewCardFacts;
 }
 export interface PlanReviewDecisionHandle {
     settle(): void;
@@ -124,7 +124,7 @@ export interface ReopenPlanReviewSharedOpts {
 }
 export interface ReopenPlanReviewFreshOpts extends ReopenPlanReviewSharedOpts {
     mintFreshQuestionId?: true;
-    deliverDecision?: (taskId: string, decision: Parameters<typeof decidePlanReview>[1], reason?: string) => void | Promise<void>;
+    deliverDecision?: (taskId: string, decision: Parameters<typeof decidePlanReview>[1], reason: string | undefined, card: PlanReviewCardFacts) => void | Promise<void>;
     wire?: PlanReviewWire;
     onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
 }

package/dist/hitl/planReviewWire.js

@@ -2,22 +2,21 @@ import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionRes
 import { hostLog } from '../host.js';
 import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
 import { clientHasVerbs, engineWireFor, noAnswerKindOf, sendOnce } from '../engineWireFor.js';
-import { engineCapTrue } from '../engineCapsCache.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
 import { decideFailureNote } from '../decideFailureNote.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { readThrownExtra, wireFailureTextsOf } from '../wireFailureShape.js';
 import { appendOwnElement, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, resumeContextUnavailableContent, resumeContextUnavailableFromError } from '../resumeRefusalCopy.js';
-import { REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
+import { APPROVAL_STALE, REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
 import { refusalDeliveryOf } from './decisionRefusal.js';
 import { directFailureVerdictOf, directSafetyStopOf } from './approvalResolution.js';
 import { __resetDecisionLedgerForTests, decisionInFlightOf, decisionKeyInFlight, decisionLedgerKeysOf, decisionOpsWithKey, decisionReadMark, dropDecisionOp, latestDecisionHandedMark, markLatestDecisionNotApplied, openDecisionOp, planDecisionKey, readMarkOf, settleDecisionOp, settleDecisionOpsOnGateLeft, } from './decisionLedger.js';
 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, planReviewUnreadableNoteRef, takePlanReviewFacts, _resetPlanReviewFactsFlightsForTest, } from './planReviewCard.js';
+import { planReviewAskAgainKey, planReviewCardNoteRef, planReviewDecisionReasonRef, planReviewUnreadableNoteRef, takePlanReviewFacts, _resetPlanReviewFactsFlightsForTest, } from './planReviewCard.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';
@@ -183,6 +182,7 @@ const armedPlanReviews = new Map();
 const offeredModeByQuestionId = new Map();
 const OFFERED_MODE_LEDGER_MAX = 64;
 export function _resetArmedPlanReviewsForTest() {
+    engineRefusedGateIds.clear();
     armedPlanReviews.clear();
     offeredModeByQuestionId.clear();
     planReviewDismissalsByKey.clear();
@@ -519,7 +519,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             const cardDelivery = cardReason !== undefined ? { ...delivery, reason: cardReason } : delivery;
             notePlanReviewAnswered(questionId);
             hostLog('debug', `planReviewWire: arm responder delivering ${decided} for task ${taskId} (path=arm)`);
-            void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, gateBefore, facts);
+            void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, facts);
             return { ok: true };
         };
         unregister = registerLocalQuestionResponder(questionId, responder);
@@ -534,7 +534,7 @@ export function planReviewOutcomeTail(taskId, decision, effect, cause) {
     switch (effect) {
         case 'took_effect':
             return decision === 'approve'
-                ? `Use TaskOutput("${taskId}") if you need the resumed task's full output, then give the user a brief report of what was done.`
+                ? `The result of the resumed task ${JSON.stringify(taskId)} arrives in its completion notification; when it arrives, give the user a brief report of what was done.`
                 : 'Briefly acknowledge to the user that the plan was rejected and continue planning.';
         case 'advanced':
             return `Tell the user the ${decision} went through and that another approval is now waiting for them; do not report the task as finished.`;
@@ -543,9 +543,9 @@ export function planReviewOutcomeTail(taskId, decision, effect, cause) {
         case 'not_sent':
             return `Nothing was sent to the engine. Do not tell the user the plan was ${decision === 'approve' ? 'approved' : 'rejected'}; the plan is still waiting for a decision.`;
         case 'not_applied':
-            return `The ${decision} did not take effect. Do not tell the user the plan was ${decision === 'approve' ? 'approved' : 'rejected'}; check the task's current state with TaskOutput("${taskId}") before saying anything about the plan.`;
+            return `The ${decision} did not take effect. Do not tell the user the plan was ${decision === 'approve' ? 'approved' : 'rejected'}; find out where task ${JSON.stringify(taskId)} stands (the background task list or its next notification shows it) before saying anything about the plan.`;
         case 'unconfirmed':
-            return `Do not state the result as fact: tell the user the ${decision} was submitted but its effect could not be confirmed; TaskOutput("${taskId}") shows where the task stands.`;
+            return `Do not state the result as fact: tell the user the ${decision} was submitted but its effect could not be confirmed; the background task list or the next notification of task ${JSON.stringify(taskId)} shows where it stands.`;
     }
 }
 function planReviewDecisionTimedOutOutcome(decision) {
@@ -632,12 +632,39 @@ export function latestPlanReviewDecisionMark(taskId) {
 export function __resetPlanReviewDecisionLatchForTests() {
     __resetDecisionLedgerForTests('plan_review');
 }
+const engineRefusedGateIds = new Set();
+const ENGINE_REFUSED_GATE_IDS_MAX = 64;
+function noteEngineRefusedGate(id) {
+    if (engineRefusedGateIds.has(id))
+        return;
+    engineRefusedGateIds.add(id);
+    while (engineRefusedGateIds.size > ENGINE_REFUSED_GATE_IDS_MAX) {
+        const oldest = engineRefusedGateIds.values().next();
+        if (oldest.done === true)
+            break;
+        engineRefusedGateIds.delete(oldest.value);
+    }
+}
+function planReviewDecisionReasonSegment(reason, card) {
+    if (reason === undefined)
+        return '';
+    try {
+        return ` ${renderMessage(planReviewDecisionReasonRef(reason, card), DATA_FACE_LANGUAGE)}`;
+    }
+    catch {
+        return '';
+    }
+}
 export async function decidePlanReview(taskId, decision, permissionModeAfter, opts) {
-    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, parkedGateIdentityOf(opts));
+    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, decisionCardOf(taskId, opts));
 }
-function parkedGateIdentityOf(opts) {
+function decisionCardOf(taskId, opts) {
     try {
-        return opts !== null && typeof opts === 'object' ? pausedCheckpointIdOf(opts.parkedResult) : undefined;
+        if (opts === null || typeof opts !== 'object')
+            return undefined;
+        const raw = readOwnDataValue(opts, 'card');
+        const facts = raw !== null && typeof raw === 'object' ? planReviewCardFactsFrom(raw) : undefined;
+        return facts !== undefined && facts.taskId === taskId ? facts : undefined;
     }
     catch {
         return undefined;
@@ -650,6 +677,8 @@ function planReviewSettledVerdict(r) {
         return status !== 'completed' && !gateMoved ? 'still_parked' : 'unconfirmed';
     if (status === 'completed')
         return 'took_effect';
+    if (status === 'running' && r.decision === 'reject')
+        return 'took_effect';
     const newGateHasCard = () => {
         const leg = durableDecideLegOf({ gateKind: r.gateKindAfter ?? null });
         return leg === 'approval' || leg === 'plan_review';
@@ -691,7 +720,7 @@ function askAgainReasonOf(card, opts) {
         return renderMessage(msg('approval.planReview.askAgain.unknown'), DATA_FACE_LANGUAGE);
     }
 }
-async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, gateBefore, card) {
+async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, card) {
     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)`);
         return;
@@ -724,7 +753,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     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, gateBefore, decision);
+        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, decision);
     }
     finally {
         releaseLatch();
@@ -745,8 +774,11 @@ function planReviewClientsFor(resolved) {
         repull: () => resolved.make({ timeoutMs: 15_000 }),
     };
 }
-async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, gateBefore, semanticDecision) {
+async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, card, semanticDecision) {
     let outcome;
+    let decisionReason;
+    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;
@@ -758,6 +790,12 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         effect = 'not_sent';
         outcome = `The plan_review ${decision} could NOT be sent: the post-approval permission mode given with it is not valid (it must be "default" or "acceptEdits"). Tell the user plainly that the decision did not go through; the plan is still waiting.`;
     }
+    else if (approvalWithheld !== undefined) {
+        hostLog('debug', `planReviewWire: not-sent decision=${decision} reason=${approvalWithheld}`);
+        effect = 'not_sent';
+        decisionReason = approvalWithheld;
+        outcome = renderMessage(msg('approval.planReview.decision.notSent', { decision }), DATA_FACE_LANGUAGE);
+    }
     else if (resolved.kind === 'no-target') {
         hostLog('error', `planReviewWire: ${decision} NOT sent — engineWireTarget() unavailable`);
         effect = 'not_sent';
@@ -777,11 +815,24 @@ 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)
+                    return undefined;
+                if (wire !== undefined) {
+                    const got = await settleWithinDeadline(PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS, (signal) => probe.runs.get(taskId, { signal }));
+                    if (got.kind === 'error')
+                        throw new Error(got.detail);
+                    if (got.kind === 'deadline')
+                        throw new Error(`post-decide status re-pull passed its ${PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS} ms deadline`);
+                    return got.value;
+                }
+                return (await probe.runs.get(taskId));
+            };
             try {
                 const mode = isPlanReviewModeAfter(permissionModeAfter) ? permissionModeAfter : undefined;
                 const reason = denyReasonForWire(opts?.reason, `plan-review ${taskId}`);
-                const capsBase = resolved.kind === 'target' ? resolved.target.baseUrl : resolved.capsBaseUrl;
-                const checkpointId = gateBefore !== undefined && engineCapTrue(capsBase, 'planReviewCheckpointId') ? gateBefore : undefined;
                 const reqBody = { decision };
                 if (reason !== undefined)
                     reqBody.reason = reason;
@@ -812,20 +863,8 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 let gateAfter;
                 let gateKindAfter;
                 try {
-                    const probe = clients.repull();
-                    if (probe) {
-                        let post;
-                        if (wire !== undefined) {
-                            const got = await settleWithinDeadline(PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS, (signal) => probe.runs.get(taskId, { signal }));
-                            if (got.kind === 'error')
-                                throw new Error(got.detail);
-                            if (got.kind === 'deadline')
-                                throw new Error(`post-decide status re-pull passed its ${PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS} ms deadline`);
-                            post = got.value;
-                        }
-                        else {
-                            post = (await probe.runs.get(taskId));
-                        }
+                    const post = await repullRow();
+                    if (post !== undefined) {
                         postStatus = bodyWordOf(post, 'status');
                         gateAfter = pausedCheckpointIdOf(post?.result);
                         gateKindAfter = pausedGateKindOf(post?.result);
@@ -837,7 +876,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 const bodyStatus = bodyWordOf(body, 'status');
                 const effective = postStatus ?? bodyStatus;
                 statusSeen = effective;
-                effect = planReviewSettledVerdict({ postStatus, bodyStatus, reparked: bodySaysReparked(body), gateBefore, gateAfter, gateKindAfter });
+                effect = planReviewSettledVerdict({ decision, postStatus, bodyStatus, reparked: bodySaysReparked(body), gateBefore, gateAfter, gateKindAfter });
                 const code = bodyWordOf(body, 'errorCode');
                 if (effect === 'still_parked' && postStatus === 'needs_review' && !bodySaysReparked(body)) {
                     outcome =
@@ -855,7 +894,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 }
                 else if (effect === 'took_effect') {
                     outcome =
-                        `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — final status: ${effective} ` +
+                        `The plan was ${decision === 'approve' ? 'approved and the parked task resumed to completion' : 'rejected (plan discarded)'} — ${effective === 'completed' ? 'final status' : 'status'}: ${effective} ` +
                             `(${postStatus !== undefined ? 'post-decide re-checked: task left the review gate' : "from the decision's own reply; the post-decide re-check was unavailable"}).`;
                 }
                 else if (effective === 'needs_review' && (gateBefore === undefined || gateAfter === undefined || postStatus !== 'needs_review')) {
@@ -898,6 +937,36 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                         `This ${decision} was not applied: the engine no longer has a pending plan review for this task — an earlier decision most likely already went through (or the review expired). ` +
                             'This is NOT a rejection of the plan and NOT a failure of the task; the answer just given simply had nothing left to act on.';
                 }
+                else if (status === 409 && refusedCode === APPROVAL_STALE) {
+                    let untrusted = false;
+                    if (checkpointId !== undefined) {
+                        const bag = readThrownExtra(e);
+                        const noCurrentPending = bag.state === 'object' &&
+                            (() => {
+                                try {
+                                    return Object.getOwnPropertyDescriptor(bag.value, 'currentPending') === undefined;
+                                }
+                                catch {
+                                    return false;
+                                }
+                            })();
+                        if (noCurrentPending) {
+                            try {
+                                const row = await repullRow();
+                                untrusted = row !== undefined && pausedCheckpointIdOf(row?.result) === checkpointId;
+                            }
+                            catch {
+                                untrusted = false;
+                            }
+                        }
+                    }
+                    if (untrusted && checkpointId !== undefined)
+                        noteEngineRefusedGate(checkpointId);
+                    hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${untrusted ? 'gate_untrusted' : 'gate_moved'}`);
+                    effect = 'not_applied';
+                    decisionReason = 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)`);
@@ -939,6 +1008,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             }
         }
     }
+    outcome = `${outcome}${planReviewDecisionReasonSegment(decisionReason, card)}`;
     const tail = planReviewOutcomeTail(taskId, decision, effect, stillParkedCause);
     const prompt = `<plan-review-outcome>\n${outcome}\n${tail}\n</plan-review-outcome>`;
     const onOutcome = opts?.onOutcome;
@@ -1087,10 +1157,10 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         ? { ...(opts.wire !== undefined ? { wire: opts.wire } : {}), ...(opts.onOutcome !== undefined ? { onOutcome: opts.onOutcome } : {}) }
         : undefined;
     const deliver = opts?.deliverDecision ??
-        ((tid, decision, reason) => {
+        ((tid, decision, reason, card) => {
             hostLog('debug', `planReviewWire: reopen responder delivering ${decision} for task ${tid} (path=reopen-default)`);
             const withReason = reason === undefined ? delivery : { ...delivery, reason };
-            void decidePlanReviewFor(tid, decision, undefined, withReason, parkedGateIdentityOf(withReason), facts);
+            void decidePlanReviewFor(tid, decision, undefined, withReason, card);
         });
     const activeKey = `${sessionKey}\u0000${canonicalId}`;
     let unregister = () => { };
@@ -1116,10 +1186,7 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         notePlanReviewDecisiveAnswerFor(sessionKey, taskId);
         notePlanReviewAnsweredFor(sessionKey, questionId);
         try {
-            if (cardReason === undefined)
-                await deliver(taskId, decided);
-            else
-                await deliver(taskId, decided, cardReason);
+            await deliver(taskId, decided, cardReason, facts);
         }
         catch (e) {
             hostLog('error', `planReviewWire: reopen decision delivery threw for task ${taskId}: ${String(e)}`);

package/dist/hitl/sessionAllowRoute.d.ts

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

package/dist/hitl/sessionAllowRoute.js

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

package/dist/hitl/sessionPolicyWire.d.ts

@@ -128,17 +128,11 @@ export interface SessionPolicyInertEntryRefusal {
 export declare function tightenSessionPolicy(facade: SessionPolicyFacade, req: SessionPolicyTightenRequest, opts?: {
     signal?: AbortSignal;
 }): Promise<SessionPolicyTightenOutcome>;
-export interface SessionPolicyTightenFacts {
-    readonly agentsStartedBeforeFirstRule?: number | undefined;
-    readonly workflowsRunning?: number | undefined;
-    readonly untrackedBackgroundItems?: number | undefined;
-    readonly inFlightUnreadable?: true | undefined;
-}
 export interface SessionPolicyDeploymentFacts {
     readonly operator?: 'present' | 'absent';
     readonly identityAttach?: 'available' | 'unavailable';
 }
-export declare function sessionPolicyTightenNotice(outcome: SessionPolicyTightenOutcome, lang?: UiLanguage, facts?: SessionPolicyTightenFacts, deployment?: SessionPolicyDeploymentFacts): string;
+export declare function sessionPolicyTightenNotice(outcome: SessionPolicyTightenOutcome, lang?: UiLanguage, deployment?: SessionPolicyDeploymentFacts): string;
 export declare function sessionPolicyReadNotice(outcome: Exclude<SessionPolicyReadOutcome, {
     kind: 'present';
 }> | {

package/dist/hitl/sessionPolicyWire.js

@@ -414,29 +414,6 @@ export async function tightenSessionPolicy(facade, req, opts) {
     return { kind: 'conflict', rev: second.retryAtRev };
 }
 const earlierGrammarNote = (lang) => renderMessage(msg('rules.sessionPolicy.tighten.earlierGrammar'), lang);
-function factSlot(facts, key) {
-    try {
-        return ownRead(facts, key);
-    }
-    catch {
-        return undefined;
-    }
-}
-function factCount(facts, key) {
-    const n = factSlot(facts, key);
-    return typeof n === 'number' && Number.isSafeInteger(n) && n >= 1 ? n : undefined;
-}
-function firstRuleWorkFactsOf(facts) {
-    const none = { agents: undefined, workflows: undefined, untracked: undefined, unreadable: false };
-    if (typeof facts !== 'object' || facts === null)
-        return none;
-    return {
-        agents: factCount(facts, 'agentsStartedBeforeFirstRule'),
-        workflows: factCount(facts, 'workflowsRunning'),
-        untracked: factCount(facts, 'untrackedBackgroundItems'),
-        unreadable: factSlot(facts, 'inFlightUnreadable') === true,
-    };
-}
 function deploymentHasNoOperator(d) {
     try {
         return typeof d === 'object' && d !== null && ownRead(d, 'operator') === 'absent';
@@ -453,28 +430,11 @@ function deploymentHasNoIdentity(d) {
         return false;
     }
 }
-export function sessionPolicyTightenNotice(outcome, lang, facts, deployment) {
+export function sessionPolicyTightenNotice(outcome, lang, deployment) {
     const say = (key, params) => renderMessage(msg(key, params), lang);
     switch (outcome.kind) {
-        case 'written': {
-            const head = say('rules.sessionPolicy.tighten.written', { rev: outcome.rev });
-            const w = firstRuleWorkFactsOf(facts);
-            const unseen = msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.unseen');
-            if (w.unreadable)
-                return `${head} ${renderMessage(msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.unreadable'), lang)} ${renderMessage(unseen, lang)}`;
-            const parts = [];
-            if (w.agents !== undefined)
-                appendOwnElement(parts, msg(w.agents === 1 ? 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.one' : 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.many', { n: w.agents }));
-            if (w.workflows !== undefined)
-                appendOwnElement(parts, msg(w.workflows === 1 ? 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.one' : 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.many', { n: w.workflows }));
-            if (w.untracked !== undefined)
-                appendOwnElement(parts, msg(w.untracked === 1 ? 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.one' : 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.many', { n: w.untracked }));
-            const [p0, p1, p2] = parts;
-            if (p0 === undefined)
-                return head;
-            const list = p1 === undefined ? p0 : p2 === undefined ? msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.two', { a: p0, b: p1 }) : msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.three', { a: p0, b: p1, c: p2 });
-            return `${head} ${renderMessage(msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.counts', { list }), lang)} ${renderMessage(unseen, lang)}`;
-        }
+        case 'written':
+            return say('rules.sessionPolicy.tighten.written', { rev: outcome.rev });
         case 'conflict':
             return say('rules.sessionPolicy.tighten.conflict');
         case 'loosen_forbidden':