@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/hitl/parkResolver.js

@@ -10,6 +10,7 @@ import { denyAttributionOf, flushHeldWithInterruptRewrite, isAskTool } from './f
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
+import { usableAskQuestions } from './parkOwnership.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
@@ -69,12 +70,11 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         return { kind: 'not_sent', lane: 'ask', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}), ...(found.rowVerdict !== undefined ? { rowVerdict: found.rowVerdict } : {}) };
     const { pending, gatedCallId } = found;
     const at = { lane: 'ask', ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
-    const fromArgs = gatedCallId
-        ? askArgsByCall.get(gatedCallId)?.questions
-        : undefined;
-    const fromPending = pending.input?.questions;
-    const questions = Array.isArray(fromArgs) && fromArgs.length > 0 ? fromArgs : fromPending;
-    if (!Array.isArray(questions) || questions.length === 0) {
+    const rowQuestions = usableAskQuestions(pending.input?.questions);
+    const streamQuestions = usableAskQuestions(gatedCallId ? askArgsByCall.get(gatedCallId)?.questions : undefined);
+    const questionsFromModelCall = rowQuestions === null && streamQuestions !== null;
+    const questions = rowQuestions ?? streamQuestions;
+    if (questions === null) {
         const truncated = pending.input?.truncated === true;
         return {
             kind: 'not_sent',
@@ -86,11 +86,17 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         };
     }
     const questionId = askGateQuestionId(approvalCallKey(gatedCallId, taskId));
+    let withdrawn;
     const answer = await new Promise(resolve => {
         const unregister = registerLocalQuestionResponder(questionId, async (_id, a) => {
             cleanup();
             resolve(a);
             return { ok: true };
+        }, (w) => {
+            withdrawn = w;
+            cleanup();
+            publishQuestionFrame({ type: 'question_complete', questionId });
+            resolve(null);
         });
         const onAbort = () => {
             cleanup();
@@ -107,8 +113,12 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         }
         signal?.addEventListener('abort', onAbort, { once: true });
         onPresented?.();
-        publishQuestionFrame({ type: 'question', questionId, questions });
+        publishQuestionFrame({ type: 'question', questionId, questions, ...(questionsFromModelCall ? { _sema_questionsFromModelCall: true } : {}) });
     });
+    if (withdrawn !== undefined) {
+        hostLog('debug', `liveHitlAskWire: question-withdrawn-by-host card=${questionId} verdict=${withdrawn.rowVerdict.kind}`);
+        return { kind: 'not_sent', ...at, cause: 'withdrawn', toldBy: withdrawn.toldBy, rowVerdict: withdrawn.rowVerdict };
+    }
     const bridge = new HitlBridge(deps.client, taskId, deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : undefined);
     if (answer === null) {
         observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, undefined, pending), taskId);
@@ -155,7 +165,7 @@ function isFetchStepNoPending(outcome) {
     return outcome.kind === 'not_sent' && outcome.cause === 'no_pending' && outcome.gatedCallId === undefined;
 }
 function isHumanDisposition(r) {
-    return r.kind === 'decided' || (r.kind === 'unsettled' && r.cause === 'interrupted') || (r.kind === 'not_sent' && r.cause === 'retracted');
+    return r.kind === 'decided' || (r.kind === 'unsettled' && r.cause === 'interrupted') || (r.kind === 'not_sent' && (r.cause === 'retracted' || r.cause === 'withdrawn'));
 }
 function failureReasonOf(r) {
     if (r.kind === 'decided')
@@ -282,7 +292,8 @@ export async function resolvePark(park, ctx) {
     if (outcome.kind !== 'decided') {
         hostLog('debug', `liveHitlAskWire: gate not decided (${outcome.kind}/${outcome.cause}: ${failureReasonOf(outcome)}) — fail-soft to suspended terminal`);
         const interrupted = outcome.kind === 'unsettled' && outcome.cause === 'interrupted';
-        const failedReason = interrupted
+        const toldByHost = outcome.kind === 'not_sent' && outcome.cause === 'withdrawn';
+        const failedReason = interrupted || toldByHost
             ? undefined
             : outcome.kind === 'not_sent' && outcome.cause === 'retracted'
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
@@ -312,13 +323,19 @@ export async function resolvePark(park, ctx) {
     };
 }
 function failsoftWayOutOf(outcome) {
+    if (outcome === undefined)
+        return 'card';
+    if (typeof outcome !== 'object' || outcome === null)
+        return 'speak';
     if (outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing')))
         return 'reason';
-    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && refusedParkFromError(outcome.refusal) !== null)
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && (refusedParkFromError(outcome.refusal) !== null || outcome.refusal?.conflict === 'row_integrity'))
         return 'cancel';
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused')
+        return 'speak';
     return 'card';
 }
-function failsoftReasonSentence(park, failedReason, terminal, wayOut = 'card') {
+function failsoftReasonSentence(park, failedReason, terminal, wayOut) {
     if (terminal !== undefined)
         return terminal.errorMessage;
     if (failedReason === undefined)
@@ -328,10 +345,9 @@ function failsoftReasonSentence(park, failedReason, terminal, wayOut = 'card') {
         return renderMessage(msg('approval.park.stillParked', { gate, reason: failedReason }));
     if (wayOut === 'cancel')
         return renderMessage(msg('approval.park.refusedNotResumable', { gate, reason: failedReason }));
-    return (`${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
-        ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.');
+    return renderMessage(msg(wayOut === 'speak' ? 'approval.park.resume.speak' : 'approval.park.resume.card', { gate, reason: failedReason }));
 }
-function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, wayOut = 'card') {
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface, wayOut) {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -360,12 +376,12 @@ export function stalledTerminal(park, ctx, stalledRounds, lastStallReason, decid
             `stopped re-attaching. Your last decision was accepted; sema did not observe the run move on after it — check the ` +
             `transcript, decide the call again if the card comes back, or cancel the run.`;
         hostLog('debug', `liveHitlAskWire: ${errorMessage}`);
-        return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, undefined, { errorCode: 'hitl_stalled', errorMessage }) };
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, undefined, { errorCode: 'hitl_stalled', errorMessage }, false, failsoftWayOutOf(undefined)) };
     }
     const reason = `the run stayed parked across ${stalledRounds} consecutive re-attach rounds without any host progress ` +
         `(last: ${lastStallReason ?? 'the engine kept parking'})`;
     hostLog('debug', `liveHitlAskWire: ${reason} — fail-soft after the round committed`);
-    return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason) };
+    return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason, undefined, false, failsoftWayOutOf(undefined)) };
 }
 function notifyParkReattach(ctx, attempt, max, reason) {
     invokeHostCallbackIsolated('liveHitlAskWire: onParkReattach', () => {

package/dist/hitl/parkedUnresumable.d.ts

@@ -0,0 +1,13 @@
+import { type CheckpointRowBar } from '../checkpointRowVerdict.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+import type { OwnedPendingListView } from './askParkRowRouting.js';
+import { type ParkOwnershipDeps } from './parkOwnership.js';
+export interface ParkedUnresumableRow {
+    readonly rowVerdict: CheckpointRowBar;
+    readonly rowKey?: string;
+    readonly taskId?: string;
+    readonly toolName?: string;
+    readonly rowDeadline?: 'armed' | 'none';
+}
+export declare function parkedUnresumableRowsOf(listed: OwnedPendingListView | null | undefined, deps?: ParkOwnershipDeps): readonly ParkedUnresumableRow[];
+export declare function parkedUnresumableLine(row: ParkedUnresumableRow, lang?: UiLanguage | (string & {})): string;

package/dist/hitl/parkedUnresumable.js

@@ -0,0 +1,80 @@
+import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, rowBarWayOutContent, } from '../checkpointRowVerdict.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
+import { approvalCallKey } from './gateIdentity.js';
+import { checkpointQueueReadingOf } from './hitlBridge.js';
+import { pendingRowIsOwnedByThisSession } from './parkOwnership.js';
+function ownNonEmpty(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+}
+function memberOf(row, rowVerdict) {
+    const taskId = ownNonEmpty(row, 'taskId');
+    const callId = ownNonEmpty(row, 'toolCallId') ?? ownNonEmpty(row, 'boundCallId');
+    const rowKey = callId !== undefined || taskId !== undefined ? approvalCallKey(callId, taskId ?? '') : undefined;
+    const toolName = ownNonEmpty(row, 'toolName');
+    const deadline = checkpointDeadlineStateOf(row);
+    return Object.freeze({
+        rowVerdict,
+        ...(rowKey !== undefined ? { rowKey } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(toolName !== undefined ? { toolName } : {}),
+        ...(deadline !== 'unknown' ? { rowDeadline: deadline } : {}),
+    });
+}
+export function parkedUnresumableRowsOf(listed, deps) {
+    if (typeof listed !== 'object' || listed === null || Array.isArray(listed)) {
+        throw new Error('approvals.list answered without a readable body — the rows this engine cannot continue are unknown');
+    }
+    const pending = listed.pending;
+    if (!Array.isArray(pending)) {
+        throw new Error('approvals.list answered without a readable `pending` array — the rows this engine cannot continue are unknown');
+    }
+    const out = [];
+    for (const row of pending) {
+        const member = parkedMemberOf(row, deps);
+        if (member !== undefined)
+            out.push(member);
+    }
+    return Object.freeze(out);
+}
+function parkedMemberOf(row, deps) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return undefined;
+        const reading = checkpointQueueReadingOf(row);
+        if (reading === undefined)
+            return undefined;
+        if (reading.foreign !== null && reading.foreign !== QUEUE_ROW_FAMILY_UNREADABLE_GATE)
+            return undefined;
+        const bar = checkpointRowBarOf(reading.r);
+        if (bar === undefined)
+            return undefined;
+        if (!pendingRowIsOwnedByThisSession(reading.r, deps))
+            return undefined;
+        return memberOf(reading.r, bar);
+    }
+    catch {
+        return undefined;
+    }
+}
+const UNREADABLE_BAR = Object.freeze({ kind: 'unreadable' });
+export function parkedUnresumableLine(row, lang) {
+    let bar = UNREADABLE_BAR;
+    let state = 'unknown';
+    try {
+        if (typeof row === 'object' && row !== null) {
+            const v = slotReadOf(row, 'rowVerdict');
+            if (v.presence === 'present')
+                bar = checkpointRowBarOf({ rowVerdict: v.value }) ?? UNREADABLE_BAR;
+            const d = slotReadOf(row, 'rowDeadline');
+            if (d.presence === 'present' && (d.value === 'armed' || d.value === 'none'))
+                state = d.value;
+        }
+    }
+    catch {
+        bar = UNREADABLE_BAR;
+        state = 'unknown';
+    }
+    return `${checkpointRowBarSentence(bar, lang)} · ${rowBarWayOutContent(bar, state, lang)}`;
+}

package/dist/hitl/permissionRuleScope.d.ts

@@ -0,0 +1,4 @@
+import type { PermissionRuleValue } from '@sema-agent/agent-types';
+export declare function isWholeToolRuleValue(value: PermissionRuleValue): boolean;
+export type AllowRuleScope = 'whole_tool' | 'content' | 'unreadable';
+export declare function allowRuleScopeOf(value: object | null | undefined): AllowRuleScope;

package/dist/hitl/permissionRuleScope.js

@@ -0,0 +1,31 @@
+import { readOwnDataValue } from '../ownKey.js';
+import { inSlotReadOf } from '../wireFailureShape.js';
+export function isWholeToolRuleValue(value) {
+    return value.ruleContent === undefined || value.ruleContent === '';
+}
+export function allowRuleScopeOf(value) {
+    try {
+        if (typeof value !== 'object' || value === null)
+            return 'unreadable';
+        const toolName = readOwnDataValue(value, 'toolName');
+        if (typeof toolName !== 'string' || toolName === '')
+            return 'unreadable';
+        let ruleContent;
+        const slot = inSlotReadOf(value, 'ruleContent');
+        if (slot.state === 'present') {
+            const raw = slot.value;
+            if (raw !== undefined) {
+                if (typeof raw !== 'string' || raw === '')
+                    return 'unreadable';
+                ruleContent = raw;
+            }
+        }
+        else if (slot.state !== 'absent')
+            return 'unreadable';
+        const snapshot = Object.freeze(Object.assign(Object.create(null), ruleContent !== undefined ? { toolName, ruleContent } : { toolName }));
+        return isWholeToolRuleValue(snapshot) ? 'whole_tool' : 'content';
+    }
+    catch {
+        return 'unreadable';
+    }
+}

package/dist/hitl/persistedRulesWire.d.ts

@@ -33,6 +33,8 @@ export interface CcImportRedeemRuleKey {
 }
 export interface CcImportRedeemRefused {
     readonly key?: CcImportRedeemRuleKey;
+    readonly reason?: string;
+    readonly detail?: string;
 }
 export interface CcImportRedeemCounts {
     persisted: number;

package/dist/hitl/persistedRulesWire.js

@@ -1,13 +1,13 @@
 import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { CORE_RULE_BEHAVIORS } from '../generated/engineFactTables.js';
-import { slotReadOf, wireFailureShapeOf } from '../wireFailureShape.js';
+import { inValueOf, 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 { appendOwnElement, guardedRead, readOwnDataValue } from '../ownKey.js';
 import { observedPermissionRulesWrite, permissionRulesWriteAvailable } from '../permissionRulesWriteCapability.js';
-import { isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
+import { isToolApprovalRespondParkedRedeemed, isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
 export function persistedRulesLaneAvailable(baseUrl) {
     return engineCapTrue(baseUrl, 'permissionRules');
 }
@@ -51,7 +51,7 @@ function ruleKeyOfRow(row) {
     const scope = keyObj === undefined ? undefined : ownNonEmpty(keyObj, 'scope');
     return behavior !== undefined && rule !== undefined && scope !== undefined ? Object.freeze({ behavior, rule, scope }) : undefined;
 }
-function indeterminateRowOf(row) {
+function unsettledRowOf(row) {
     const key = ruleKeyOfRow(row);
     const reason = ownNonEmpty(row, 'reason');
     const d = slotReadOf(row, 'detail');
@@ -62,10 +62,6 @@ function indeterminateRowOf(row) {
         ...(shown !== undefined && shown.trim() !== '' ? { detail: shown } : {}),
     });
 }
-function refusedRowOf(row) {
-    const key = ruleKeyOfRow(row);
-    return Object.freeze(key !== undefined ? { key } : {});
-}
 const RECEIPT_ROW_ARMS = {
     persisted: (acc) => {
         acc.persisted += 1;
@@ -74,10 +70,10 @@ const RECEIPT_ROW_ARMS = {
         acc.deduped += 1;
     },
     refused: (acc, row) => {
-        appendOwnElement(acc.refused, refusedRowOf(row));
+        appendOwnElement(acc.refused, unsettledRowOf(row));
     },
     indeterminate: (acc, row) => {
-        appendOwnElement(acc.indeterminate, indeterminateRowOf(row));
+        appendOwnElement(acc.indeterminate, unsettledRowOf(row));
     },
 };
 function receiptCountsOf(rows) {
@@ -333,9 +329,14 @@ export function revokeTargetFromPersistedRule(rule, opts) {
     };
 }
 function readPrincipalOverride(carrier) {
-    if (carrier === null || typeof carrier !== 'object' || !('principal' in carrier))
+    if (carrier === null || typeof carrier !== 'object')
         return { ok: true };
-    const raw = carrier.principal;
+    const slot = inValueOf(carrier, 'principal');
+    if (slot.state === 'absent')
+        return { ok: true };
+    if (slot.state === 'unproven')
+        return { ok: false };
+    const raw = slot.value;
     if (typeof raw !== 'string' || raw.trim().length === 0)
         return { ok: false };
     return { ok: true, principal: raw };
@@ -636,7 +637,7 @@ export function classifySkippedReason(reason) {
 }
 export function readRulePersistOutcome(ack) {
     const parsed = readToolApprovalRespondAck(ack);
-    if (parsed === undefined || isToolApprovalRespondReplayed(parsed))
+    if (parsed === undefined || isToolApprovalRespondReplayed(parsed) || isToolApprovalRespondParkedRedeemed(parsed))
         return { state: 'unknown' };
     if (parsed.rulePersisted === true)
         return { state: 'persisted' };

package/dist/hitl/planReviewWire.js

@@ -498,11 +498,15 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         armedPlanReviews.set(taskId, instance);
         armedTaskId = taskId;
         let unregister = () => { };
+        const onWithdraw = () => {
+            hostLog('debug', `planReviewWire: card-withdrawn-by-host task=${taskId} card=${questionId}`);
+            retireArmedPlanReview(taskId, instance);
+        };
         const responder = async (_id, answer) => {
             const choice = planReviewAnswerChoiceOf(questionId, answer);
             if (choice === 'inadmissible') {
                 if (armedPlanReviews.get(taskId) === instance && !hasLocalQuestionResponder(questionId))
-                    unregister = registerLocalQuestionResponder(questionId, responder);
+                    unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
                 hostLog('debug', `planReviewWire: answer-inadmissible card=${questionId}`);
                 return { ok: false, inadmissible: true };
             }
@@ -523,7 +527,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, facts);
             return { ok: true };
         };
-        unregister = registerLocalQuestionResponder(questionId, responder);
+        unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
         publishArmedPlanReviewCard(instance);
         hostLog('debug', `planReviewWire: approval card armed for parked plan (task ${taskId})`);
     }
@@ -1160,11 +1164,17 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         });
     const activeKey = `${sessionKey}\u0000${canonicalId}`;
     let unregister = () => { };
+    const onWithdraw = () => {
+        hostLog('debug', `planReviewWire: card-withdrawn-by-host task=${taskId} card=${questionId}`);
+        if (activeReopenResponders.get(activeKey)?.questionId === questionId)
+            activeReopenResponders.delete(activeKey);
+        publishQuestionFrameFor(sessionKey, { type: 'question_complete', questionId });
+    };
     const responder = async (_id, answer) => {
         const choice = planReviewAnswerChoiceOf(questionId, answer);
         if (choice === 'inadmissible') {
             if (activeReopenResponders.get(activeKey)?.questionId === questionId && !hasLocalQuestionResponder(questionId)) {
-                unregister = registerLocalQuestionResponder(questionId, responder);
+                unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
             }
             hostLog('debug', `planReviewWire: answer-inadmissible card=${questionId}`);
             return { ok: false, inadmissible: true };
@@ -1190,7 +1200,7 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         return { ok: true };
     };
     const shape = cardShapeOf(facts, false);
-    unregister = registerLocalQuestionResponder(questionId, responder);
+    unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
     activeReopenResponders.set(activeKey, { questionId, unregister: () => unregister(), shape });
     const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
     publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(questionId, REOPEN_QUESTION, shape, facts));

package/dist/hitl/sessionAllowRoute.js

@@ -1,3 +1,4 @@
+import { inSlotReadOf } from '../wireFailureShape.js';
 export function sessionAllowCarried(leg, approvalId) {
     if (leg === 'frame')
         return true;
@@ -7,10 +8,10 @@ export function sessionAllowCarried(leg, approvalId) {
 }
 export function readCardUnreadableEvidence(card) {
     try {
-        if (!('unreadableEvidence' in card))
+        const slot = inSlotReadOf(card, 'unreadableEvidence');
+        if (slot.state === 'absent')
             return 'absent';
-        const d = Object.getOwnPropertyDescriptor(card, 'unreadableEvidence');
-        const list = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+        const list = slot.state === 'present' ? slot.value : undefined;
         return Array.isArray(list) && list.every((k) => typeof k === 'string') ? list : 'unreadable';
     }
     catch {
@@ -21,7 +22,7 @@ export function sessionAllowCardReadable(card) {
     if (typeof card !== 'object' || card === null)
         return 'card_unreadable';
     try {
-        if ('cardPayloadUnreadable' in card)
+        if (inSlotReadOf(card, 'cardPayloadUnreadable').state !== 'absent')
             return 'card_unreadable';
     }
     catch {

package/dist/hitl/sessionPolicyWire.js

@@ -701,10 +701,12 @@ export function sessionPolicyRemovalNotice(outcome, deployment) {
             return 'This session’s rule record holds no entry naming a tool the engine refuses that the supplied roster does not mount, so nothing was changed. If runs still fail at startup over a refused tool name, that entry is set somewhere this record does not cover — the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules — or it is a name the engine refuses that this version does not yet recognise, or the failing run does not mount a tool the supplied roster has under that name.';
         case 'judge_failed':
             return 'Nothing was changed: this client could not check which entries in this session’s rule record name a tool the engine refuses (its copy of the engine’s tool-name check is unavailable or gave no clear answer), so it removed none rather than guess. Removing them needs that check available in this client.';
-        case 'loosen_forbidden':
-            if (deploymentHasNoOperator(deployment))
-                return renderMessage(msg('rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden'));
-            return 'The engine refused to take these entries out of this session’s rule record: on this engine only an operator can remove entries from it, so the record is unchanged. Ask an operator to remove them, or continue in a new session.';
+        case 'loosen_forbidden': {
+            const stem = msg('rules.sessionPolicy.remove.loosenForbiddenStem');
+            return deploymentHasNoOperator(deployment)
+                ? renderMessage(msg('rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden', { stem }))
+                : renderMessage(msg('rules.sessionPolicy.remove.loosenForbidden', { stem }));
+        }
         case 'conflict':
             return 'This session’s rule record was changed by someone else while the refused entries were being removed, twice in a row — nothing was changed. Try again once the other change has finished.';
         case 'read_failed':

package/dist/hitl/standingRows.d.ts

@@ -18,6 +18,7 @@ export interface StandingRowsHostFacts {
 }
 export declare function standingRowsOf(card: object | null | undefined, host?: StandingRowsHostFacts | null): StandingRows;
 export declare function seatSessionRowOf(card: object | null | undefined, requestId: string | undefined): boolean;
+export declare function seatAllowNoteCarriedOf(card: object | null | undefined, requestId: string | undefined): boolean;
 export type RememberOffer = 'offerable' | 'refused' | 'unknown';
 export interface RememberOfferable {
     readonly session: RememberOffer;
@@ -25,13 +26,9 @@ export interface RememberOfferable {
     readonly deploymentList: RememberOffer;
 }
 export declare function rememberOfferable(card: object | null | undefined, host?: StandingRowsHostFacts | null): RememberOfferable;
-export interface LocalAllowRuleHostFacts {
-    readonly hostLadderEnforces?: boolean;
-}
 export interface LocalAllowRuleEnforcement {
     readonly enforceable: boolean;
-    readonly by?: 'host_ladder' | 'engine_grant';
     readonly engine: 'sent' | 'kept' | 'unreadable';
     readonly keptReason?: PermissionsKeptReason;
 }
-export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading, host?: LocalAllowRuleHostFacts | null): LocalAllowRuleEnforcement;
+export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading): LocalAllowRuleEnforcement;

package/dist/hitl/standingRows.js

@@ -1,7 +1,8 @@
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPairState } from './askClassPair.js';
-import { automaticAnswerVerdict } from './automaticAnswerVerdict.js';
-import { readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
+import { askLevelVerdict } from './automaticAnswerVerdict.js';
+import { answerCarriage, readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
+import { inSlotReadOf, inValueOf } from '../wireFailureShape.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
 import { permissionsDeclarationReport } from '../permissionsDeclaration.js';
 import { readCardUnreadableEvidence, sessionAllowCardReadable, sessionAllowEligible } from './sessionAllowRoute.js';
@@ -15,9 +16,10 @@ function ownData(v, key) {
         return undefined;
     }
 }
-function hasKey(v, key) {
+function candidateSlot(v, key) {
     try {
-        return { inCard: key in v };
+        const s = inSlotReadOf(v, key);
+        return s.state === 'unproven' ? UNREADABLE : s;
     }
     catch {
         return UNREADABLE;
@@ -25,8 +27,10 @@ function hasKey(v, key) {
 }
 function present(v, key) {
     try {
-        const inCard = key in v;
-        return { inCard, value: inCard ? v[key] : undefined };
+        const s = inValueOf(v, key);
+        if (s.state === 'unproven')
+            return UNREADABLE;
+        return s.state === 'present' ? { inCard: true, value: s.value } : { inCard: false, value: undefined };
     }
     catch {
         return UNREADABLE;
@@ -42,12 +46,12 @@ function persistentRowOf(card, host, evidenceUnreadable) {
     if (evidenceUnreadable)
         return { row: 'none', why: 'evidence_unreadable' };
     for (const key of ['ruleOffers', 'ruleOffersReadOnly']) {
-        const p = hasKey(card, key);
+        const p = candidateSlot(card, key);
         if (p === UNREADABLE)
             return UNREADABLE;
-        if (!p.inCard)
+        if (p.state === 'absent')
             continue;
-        const offers = readRuleOffers(ownData(card, key));
+        const offers = readRuleOffers(p.state === 'present' ? p.value : undefined);
         if (offers === undefined || offers.length === 0)
             return { row: 'none', why: 'offers_unreadable' };
         return { row: 'engine_offer', why: 'given' };
@@ -69,7 +73,7 @@ function persistentRowOf(card, host, evidenceUnreadable) {
         return { row: 'none', why: 'tool_name_unreadable' };
     if (tool === CORE_SKILL_TOOL_NAME)
         return { row: 'none', why: 'grant_binding' };
-    if (automaticAnswerVerdict(card, 'standing_rule').kind !== 'may_answer')
+    if (askLevelVerdict(card, 'standing_rule').kind !== 'may_answer')
         return { row: 'none', why: 'rule_cannot_clear' };
     const face = readApprovalCardWord(card);
     if (face === undefined)
@@ -149,6 +153,20 @@ export function seatSessionRowOf(card, requestId) {
         return false;
     }
 }
+export function seatAllowNoteCarriedOf(card, requestId) {
+    if (typeof card !== 'object' || card === null)
+        return false;
+    try {
+        if (Object.hasOwn(card, 'requestId'))
+            return false;
+        if (toolPermissionRequestIdDomain(requestId) !== 'durable:')
+            return false;
+        return answerCarriage(card).allowNote === 'model';
+    }
+    catch {
+        return false;
+    }
+}
 const SESSION_OFFER = Object.freeze({
     given: 'offerable',
     card_unreadable: 'unknown',
@@ -178,8 +196,7 @@ export function rememberOfferable(card, host) {
         deploymentList: SESSION_OFFER[rows.why.deploymentList],
     });
 }
-export function localAllowRuleEnforceable(rule, caps, host) {
-    const ladder = typeof host === 'object' && host !== null && ownData(host, 'hostLadderEnforces') === true;
+export function localAllowRuleEnforceable(rule, caps) {
     let engine = 'unreadable';
     let keptReason;
     if (typeof rule === 'string' && rule.trim() !== '') {
@@ -199,10 +216,8 @@ export function localAllowRuleEnforceable(rule, caps, host) {
             engine = 'unreadable';
         }
     }
-    const by = ladder ? 'host_ladder' : engine === 'sent' ? 'engine_grant' : undefined;
     return Object.freeze({
-        enforceable: by !== undefined,
-        ...(by !== undefined ? { by } : {}),
+        enforceable: engine === 'sent',
         engine,
         ...(keptReason !== undefined ? { keptReason } : {}),
     });