@sema-agent/client-core 0.106.0 → 0.107.0

package/dist/hitl/parkOwnership.js

@@ -2,6 +2,7 @@ import { isOwnEngineRun } from '../subagentContentStore.js';
 import { rowIdTail } from '../workflow.js';
 import { hostSessionFor } from '../host.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { pendingRowIsOfSession } from './parkRowDelegation.js';
 export function pendingRowIsOwnedByThisSession(row, deps) {
     const sessionKey = deps?.sessionKey ?? DEFAULT_SESSION_KEY;
     const rowTaskId = typeof row.taskId === 'string' ? row.taskId : '';
@@ -14,11 +15,9 @@ export function pendingRowIsOwnedByThisSession(row, deps) {
     }
     const currentSessionId = deps?.currentSessionId ?? (() => hostSessionFor(sessionKey)?.currentSessionId());
     const sessionId = currentSessionId();
-    const rowSessionId = typeof row.sessionId === 'string' ? row.sessionId : '';
-    return (typeof sessionId === 'string' &&
-        sessionId.length > 0 &&
-        rowSessionId.length > 0 &&
-        rowSessionId === sessionId);
+    if (typeof sessionId !== 'string' || sessionId.length === 0)
+        return false;
+    return pendingRowIsOfSession(row, sessionId);
 }
 export function askQuestionsFromPending(pending) {
     const input = pending.input;

package/dist/hitl/parkResolver.js

@@ -12,6 +12,7 @@ import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -63,7 +64,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
     }
     const found = await findPendingForTask(deps.client, taskId, isAskTool, signal ? { signal } : undefined, parkGatedCallId, (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
     if (!found.ok)
-        return { kind: 'not_sent', lane: 'ask', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}) };
+        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
@@ -284,7 +285,8 @@ export async function resolvePark(park, ctx) {
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
                 : failureReasonOf(outcome);
         const noDecisionSurface = outcome.kind === 'not_sent' && outcome.cause === 'card_unavailable' && outcome.detail !== undefined && isNoDecisionSurfaceReason(outcome.detail);
-        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface) };
+        const undecidableHere = outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing'));
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, interrupted, failedReason, undefined, noDecisionSurface, undecidableHere) };
     }
     led.dropHeldForDecidedPark(outcome.gatedCallId, park.gatedCallId);
     if (outcome.gatedCallId) {
@@ -307,15 +309,17 @@ export async function resolvePark(park, ctx) {
         ...(handoffTaskId !== undefined ? { handoffTaskId } : {}),
     };
 }
-function failsoftReasonSentence(park, failedReason, terminal) {
+function failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut = false) {
     if (terminal !== undefined)
         return terminal.errorMessage;
     if (failedReason === undefined)
         return undefined;
+    if (reasonCarriesWayOut)
+        return renderMessage(msg('approval.park.stillParked', { gate: park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion', 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.');
 }
-function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false) {
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, reasonCarriesWayOut = false) {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -323,7 +327,7 @@ function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, no
             gateAbortedByUser,
         }),
     ];
-    const reason = failsoftReasonSentence(park, failedReason, terminal);
+    const reason = failsoftReasonSentence(park, failedReason, terminal, reasonCarriesWayOut);
     if (park.pendingDone) {
         events.push(reason === undefined || noDecisionSurface ? park.pendingDone : inheritFrameBinding(park.pendingDone, { ...park.pendingDone, _sema_park_failed_reason: reason }));
     }

package/dist/hitl/parkRowBirthWait.d.ts

@@ -1,3 +1,4 @@
+import type { CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 export type ParkRowProbe<Row> = {
     kind: 'row';
     row: Row;
@@ -7,6 +8,9 @@ export type ParkRowProbe<Row> = {
 } | {
     kind: 'settled';
     reason: string;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 };
 export type ParkRowWaitVerdict<Row> = {
     kind: 'row';
@@ -23,6 +27,9 @@ export type ParkRowWaitVerdict<Row> = {
     reason: string;
     waitedMs: number;
     probes: number;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 } | {
     kind: 'aborted';
     waitedMs: number;

package/dist/hitl/parkRowBirthWait.js

@@ -103,7 +103,7 @@ export async function waitForParkRowBirth(deps) {
         if (probed.kind === 'row')
             return { kind: 'row', row: probed.row, waitedMs: now() - startedAt, probes };
         if (probed.kind === 'settled') {
-            return { kind: 'settled', reason: probed.reason, waitedMs: now() - startedAt, probes };
+            return { kind: 'settled', reason: probed.reason, waitedMs: now() - startedAt, probes, ...(probed.rowVerdict !== undefined ? { rowVerdict: probed.rowVerdict } : {}) };
         }
         lastReason = probed.reason;
         const remainingMs = budgetMs - (now() - startedAt);

package/dist/hitl/parkRowDelegation.d.ts

@@ -0,0 +1,6 @@
+export interface ParkRowDelegationLinks {
+    readonly parentSessionId?: string;
+    readonly rootSessionId?: string;
+}
+export declare function pendingRowIsOfSession(row: object, sessionId: string): boolean;
+export declare function parkRowDelegationLinksOf(row: object | null | undefined): ParkRowDelegationLinks | undefined;

package/dist/hitl/parkRowDelegation.js

@@ -0,0 +1,33 @@
+import { slotReadOf } from '../wireFailureShape.js';
+export function pendingRowIsOfSession(row, sessionId) {
+    if (sessionId.length === 0)
+        return false;
+    const rowSessionId = typeof row.sessionId === 'string' ? row.sessionId : '';
+    if (rowSessionId.length > 0 && rowSessionId === sessionId)
+        return true;
+    const links = parkRowDelegationLinksOf(row);
+    return links !== undefined && (links.parentSessionId === sessionId || links.rootSessionId === sessionId);
+}
+export function parkRowDelegationLinksOf(row) {
+    try {
+        if (typeof row !== 'object' || row === null)
+            return undefined;
+        const a = slotReadOf(row, 'agent');
+        if (a.presence !== 'present' || typeof a.value !== 'object' || a.value === null)
+            return undefined;
+        const agent = a.value;
+        const link = (key) => {
+            const r = slotReadOf(agent, key);
+            return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+        };
+        const parentSessionId = link('parentSessionId');
+        const rootSessionId = link('rootSessionId');
+        return Object.freeze({
+            ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+            ...(rootSessionId !== undefined ? { rootSessionId } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/persistedRulesWire.d.ts

@@ -1,4 +1,4 @@
-import type { CcImportLayer, CcImportPrepareResult, CcImportRedeemResult, PersistedRule, RuleBehavior, RuleListParams, RuleListResult, RuleRevokeRequest, RemovalLiveness, RuleRevokeResult, RuleWriteRequest, RuleWriteResult } from '@sema-agent/sdk';
+import type { CcImportLayer, CcImportPrepareResult, PersistedRule, RuleBehavior, RuleListParams, RuleListResult, RuleRevokeRequest, RemovalLiveness, RuleRevokeResult, RuleWriteRequest, RuleWriteResult, RulesResource } from '@sema-agent/sdk';
 import type { UiLanguage } from '../env/uiLanguage.js';
 export interface RulesFacade {
     list(params?: RuleListParams, opts?: {
@@ -15,17 +15,29 @@ export interface RulesFacade {
     }): Promise<CcImportPrepareResult>;
     ccImportRedeem(ticket: string, opts?: {
         signal?: AbortSignal;
-    }): Promise<CcImportRedeemResult>;
+    }): ReturnType<RulesResource['ccImportRedeem']>;
 }
 export type RulesListFacade = Pick<RulesFacade, 'list'>;
 export declare function persistedRulesLaneAvailable(baseUrl: string | undefined): boolean;
 export declare function persistedRulesGovernanceAvailable(baseUrl: string | undefined): boolean;
 export declare function persistedRulesWriteAvailable(baseUrl: string | undefined): boolean;
+export interface CcImportRedeemIndeterminate {
+    readonly key?: CcImportRedeemRuleKey;
+    readonly reason?: string;
+    readonly detail?: string;
+}
+export interface CcImportRedeemRuleKey {
+    readonly behavior: string;
+    readonly rule: string;
+    readonly scope: string;
+}
 export interface CcImportRedeemCounts {
     persisted: number;
     deduped: number;
+    indeterminate: readonly CcImportRedeemIndeterminate[];
 }
-export declare function readCcImportRedeemCounts(result: unknown): CcImportRedeemCounts | null;
+export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'indeterminate';
+export declare function readCcImportRedeemCounts(body: unknown): CcImportRedeemCounts | null;
 export type RulesFailure = {
     kind: 'lane-unavailable';
     message: string;

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/planReviewWire.js

@@ -677,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';
@@ -874,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 =
@@ -892,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')) {

package/dist/hitl/sessionAllowRoute.d.ts

@@ -1,2 +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

@@ -5,3 +5,45 @@ export function sessionAllowCarried(leg, approvalId) {
         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/standingRows.js

@@ -4,6 +4,7 @@ import { readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
 import { permissionsDeclarationReport } from '../permissionsDeclaration.js';
+import { readCardUnreadableEvidence, sessionAllowCardReadable, sessionAllowEligible } from './sessionAllowRoute.js';
 const UNREADABLE = Symbol('unreadable');
 function ownData(v, key) {
     try {
@@ -90,18 +91,17 @@ function enginePremiseOf(card) {
         return 'card_unreadable';
     if (refused.inCard)
         return refused.value === true ? 'remember_refused' : 'remember_unreadable';
-    const evidence = present(card, 'unreadableEvidence');
-    if (evidence === UNREADABLE)
+    const list = readCardUnreadableEvidence(card);
+    if (list === 'unreadable')
         return 'card_unreadable';
-    if (!evidence.inCard)
+    if (list === 'absent')
         return { evidenceUnreadable: false };
-    const list = ownData(card, 'unreadableEvidence');
-    if (!Array.isArray(list) || !list.every((k) => typeof k === 'string'))
-        return 'card_unreadable';
     if (list.includes('rememberRefused'))
         return 'remember_unreadable';
     return { evidenceUnreadable: list.length > 0 };
 }
+const _sessionWhyPin = true;
+void _sessionWhyPin;
 export function standingRowsOf(card, host) {
     if (typeof card !== 'object' || card === null)
         return allClosed('card_unreadable');
@@ -110,11 +110,11 @@ export function standingRowsOf(card, host) {
         if (typeof premise === 'string')
             return allClosed(premise);
         const evidenceUnreadable = premise.evidenceUnreadable;
-        const sessionRow = ownData(card, 'allowSessionCarried') === true;
-        const sessionWhy = sessionRow ? 'given' : 'route_cannot_carry';
+        const sessionWhy = sessionAllowEligible(card);
+        const sessionRow = sessionWhy === 'given';
         let deploymentList;
         if (!sessionRow) {
-            deploymentList = 'route_cannot_carry';
+            deploymentList = sessionWhy;
         }
         else {
             const pair = readAskClassPairState(card);
@@ -143,7 +143,7 @@ export function seatSessionRowOf(card, requestId) {
         const domain = toolPermissionRequestIdDomain(requestId);
         if (domain !== 'live:' && domain !== 'durable:')
             return false;
-        return typeof enginePremiseOf(card) !== 'string';
+        return typeof enginePremiseOf(card) !== 'string' && sessionAllowCardReadable(card) === 'given';
     }
     catch {
         return false;

package/dist/hitl/toolApprovalWire.js

@@ -15,7 +15,7 @@ import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
 import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
 import { msg, renderMessage } from '../i18n/translate.js';
-import { sessionAllowCarried } from './sessionAllowRoute.js';
+import { sessionAllowCarried, sessionAllowEligible } from './sessionAllowRoute.js';
 import { INTERRUPT_DENY_REASON, observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { displayUntrusted, quoteUntrustedForSentence } from '../displayUntrusted.js';
@@ -449,7 +449,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         closeDurableRead(readMark);
     }
     if (!found.ok)
-        return { kind: 'not_sent', lane: 'decide', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}) };
+        return { kind: 'not_sent', lane: 'decide', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}), ...(found.rowVerdict !== undefined ? { rowVerdict: found.rowVerdict } : {}) };
     if (held !== undefined)
         return joinDurableDecision(held, deps, signal);
     const rowIdentity = parkRowHolderIdentity(found.pending, found.gatedCallId);
@@ -500,7 +500,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
     const durableRuleOffersAbsence = pending.ruleOffersAbsence;
     hold.presented = true;
     deps.onPresented?.();
-    const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, withUnreadableEvidence(pending, 'row', {
+    const cardRequest = withUnreadableEvidence(pending, 'row', {
         toolName,
         args,
         callKey,
@@ -533,7 +533,8 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
         allowSessionCarried: true,
         grantBinding: readApprovalGrantBinding(pending),
         parkRow: parkRowOf(taskId, pending, gatedCallId),
-    }));
+    });
+    const card = await surfaceCallTrackedCard(gatedCallId, undefined, ledgerSlot, cardRequest);
     hold.phase = 'respond';
     if (rowArgsGap !== undefined && card.kind === 'allow' && card.updatedInput !== undefined) {
         hostLog('error', `liveToolApprovalWire: approval card for ${gatedCallId ?? `task ${taskId}`} returned an edited approval, but the tool input is ${rowArgsGap === 'truncated' ? 'a size marker on the pending row' : 'missing from both the stream and the pending row'} — nothing sent (the park stays pending)`);
@@ -560,10 +561,15 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                 let rememberStop;
                 try {
                     let rememberRefused = false;
-                    const approveBody = answerPayloadFor(card, 'decide');
+                    const sessionAllowWhy = sessionAllowEligible(cardRequest);
+                    const sessionDowngraded = card.allowSession === true && sessionAllowWhy !== 'given';
+                    if (sessionDowngraded)
+                        hostLog('debug', `liveToolApprovalWire: ${gatedCallId ?? `task ${taskId}`} session-wide allow taken as allow-once — the card is not eligible (${sessionAllowWhy})`);
+                    const answered = sessionDowngraded ? { ...card, allowSession: false } : card;
+                    const approveBody = answerPayloadFor(answered, 'decide');
                     const { remember: _remember, ...plainApproveBody } = approveBody;
                     void _remember;
-                    emitAnswerCommitted(callKey, 'decide', card, approveBody);
+                    emitAnswerCommitted(callKey, 'decide', answered, approveBody);
                     if (approveBody.remember === 'session') {
                         let sessionReceipt;
                         let sessionDecided = false;
@@ -591,7 +597,7 @@ async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, foun
                     }
                     const raw = await bridge.decideTool(plainApproveBody, gatedCallId, decideOpts, pending);
                     const receipt = readDecideReceipt(raw);
-                    if (rememberRefused)
+                    if (rememberRefused || sessionDowngraded)
                         surfaceRememberNotApplied();
                     return { kind: 'decided', ...at, decision: 'allow', ...(receipt !== undefined ? { receipt } : {}) };
                 }
@@ -2038,9 +2044,15 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
     enterLiveRespondPhase(hold);
     const noteCapable = lane?.approvalDecisionNoteCapable === true;
     const denyReasonRead = card.kind === 'deny' ? ((r) => (typeof r === 'string' ? r : undefined))(card.reason) : undefined;
+    const sessionAllowWhy = sessionAllowEligible(facts);
+    const sessionDowngraded = card.kind === 'allow' && card.allowSession === true && sessionAllowWhy !== 'given';
+    if (sessionDowngraded)
+        hostLog('debug', `liveToolApprovalWire: ${approvalId} session-wide allow taken as allow-once — the card is not eligible (${sessionAllowWhy})`);
     const answerSnapshot = card.kind === 'deny'
         ? ((by) => ({ kind: 'deny', ...(denyReasonRead !== undefined ? { reason: denyReasonRead } : {}), ...(by !== undefined ? { settledBy: by } : {}) }))(readApprovalDenySettledBy(card))
-        : card;
+        : sessionDowngraded && card.kind === 'allow'
+            ? { ...card, allowSession: false }
+            : card;
     const basePayload = answerPayloadFor(answerSnapshot, 'respond', { approvalDecisionNoteCapable: noteCapable });
     const decision = basePayload?.decision ?? 'deny';
     if (card.kind === 'allow' && typeof card.note === 'string' && card.note.trim() !== '' && answerCarriage({ callKey: liveFrameCallKey(approvalId) }).allowNote === 'none') {
@@ -2273,6 +2285,8 @@ async function presentToolApprovalFrameAndRespond(frame, carriers, approvalId, r
             logAfterDecided(`liveToolApprovalWire: ${approvalId} allow_session ack rememberApplied=false — grant not stored, surfacing honest notice`);
             surfaceRememberNotApplied();
         }
+        if (replayed === undefined && sessionDowngraded)
+            surfaceRememberNotApplied();
         if (respondOpts.updatedInput !== undefined && applied?.updatedInputForwarded === false) {
             logAfterDecided(`liveToolApprovalWire: ${approvalId} edited args were NOT forwarded (ack.updatedInputForwarded=false) — the tool runs on the ORIGINAL input`);
             surfaceEditNotForwarded();

package/dist/i18n/messages.en.d.ts

@@ -247,6 +247,10 @@ declare const EN: {
     'approval.settle.cause.streamDisconnected': string;
     'approval.settle.cause.undeliverable': string;
     'approval.decide.requiresBinding': string;
+    'approval.decide.unboundWayOut': string;
+    'approval.rowUnresumable.fallback': string;
+    'approval.rowUnresumable.askNotSurfaced': string;
+    'approval.park.stillParked': string;
     'approval.decision.grantChanged': string;
     'approval.decision.settledElsewhereContrary.deniedFirst': string;
     'approval.decision.settledElsewhereContrary.approvedFirst': string;
@@ -422,6 +426,7 @@ declare const EN: {
     'session.selfHeal.row.askDecided.inferred': string;
     'session.selfHeal.row.askDecided.releaseUnknown': string;
     'session.selfHeal.row.askReopenFailed.withKeep': string;
+    'session.selfHeal.row.askReopenFailed.rowUnresumable': string;
     'session.selfHeal.row.askReopenFailed.noKeep': string;
     'session.selfHeal.row.planReopenFailed.dismissed': string;
     'session.selfHeal.row.planReopenFailed.withKeep': string;
@@ -983,6 +988,7 @@ declare const EN: {
     'notice.wireRefusal.hostPosture.both': string;
     'notice.wireRefusal.hostPosture.unattributed': string;
     'notice.wireRefusal.autonomyLane': string;
+    'notice.wireRefusal.sessionArchiveStamped': string;
     'notice.wireRefusal.unsupportedRule': string;
     'notice.wireRefusal.unsupportedRule.other': string;
     'notice.wireRefusal.unsupportedRule.stored': string;