@sema-agent/client-core 0.106.0 → 0.107.0

package/dist/engineNoticeCodes.js

@@ -3,20 +3,21 @@ import { displayUntrusted } from './displayUntrusted.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_APPROVAL_REMEDY_KINDS, CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
 function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
 }
+const LEGACY_NOTICE_AUDIENCE = Object.freeze({ 'context.image_removed': 'user', 'session.records_skipped': 'user' });
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && CATALOG.has(code);
+    return typeof code === 'string' && (CATALOG.has(code) || Object.hasOwn(LEGACY_NOTICE_AUDIENCE, code));
 }
 export const ENGINE_NOTICE_AUDIENCE = CORE_NOTICE_AUDIENCE;
 export function noticeAudienceOf(code) {
     if (typeof code !== 'string')
         return 'operator';
-    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(LEGACY_NOTICE_AUDIENCE, code) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = CORE_MCP_INJECTION_DROP_REASONS;
 const DROP_REASONS = new Set(MCP_INJECTION_DROP_REASONS);
@@ -536,6 +537,15 @@ function optionalOwnSeat(o, key) {
         return undefined;
     }
 }
+const UNREADABLE = Symbol('unreadable');
+function ownSeatOrUnreadable(o, key) {
+    try {
+        return ownSeat(o, key);
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
 function readToolTurnRepairedOf(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
@@ -716,7 +726,10 @@ function readUserInputUndrainedOf(notice) {
     const taskId = nonEmpty(optionalOwnSeat(o, 'taskId'));
     const sessionId = nonEmpty(optionalOwnSeat(o, 'sessionId'));
     const runId = nonEmpty(optionalOwnSeat(o, 'runId'));
-    const childSessionId = nonEmpty(optionalOwnSeat(o, 'childSessionId'));
+    const childSeat = ownSeatOrUnreadable(o, 'childSessionId');
+    const childSessionId = nonEmpty(childSeat);
+    const childSeatProven = childSeat === undefined || childSessionId !== undefined;
+    const inputIds = childSeatProven ? exactInputIdList(optionalOwnSeat(o, 'inputIds'), count) : undefined;
     return {
         kind,
         count,
@@ -725,8 +738,96 @@ function readUserInputUndrainedOf(notice) {
         ...(sessionId !== undefined ? { sessionId } : {}),
         ...(runId !== undefined ? { runId } : {}),
         ...(childSessionId !== undefined ? { childSessionId } : {}),
+        ...(inputIds !== undefined ? { inputIds } : {}),
     };
 }
+function exactInputIdList(v, count) {
+    try {
+        if (!Array.isArray(v) || ownDataField(v, 'length') !== count)
+            return undefined;
+        const out = [];
+        const seen = new Set();
+        for (let i = 0; i < count; i++) {
+            const d = Object.getOwnPropertyDescriptor(v, i);
+            const id = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+            if (typeof id !== 'string' || id.length === 0 || seen.has(id))
+                return undefined;
+            seen.add(id);
+            out.push(id);
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
+function strictSeat(o, key) {
+    try {
+        return ownDataField(o, key);
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function ledgerIdSet(ledger, key) {
+    const list = strictSeat(ledger, key);
+    if (list === undefined)
+        return new Set();
+    try {
+        if (!Array.isArray(list))
+            return UNREADABLE;
+        const out = new Set();
+        for (const k of Object.getOwnPropertyNames(list)) {
+            if (k === 'length' || String(Number(k) >>> 0) !== k || Number(k) === 4294967295)
+                continue;
+            const id = strictSeat(list, k);
+            if (id === UNREADABLE)
+                return UNREADABLE;
+            if (typeof id === 'string' && id.length > 0)
+                out.add(id);
+        }
+        return out;
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+export function undrainedInputsVerdict(facts, ledger) {
+    if (facts === null || typeof facts !== 'object')
+        return undefined;
+    try {
+        if (Array.isArray(facts))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const count = positiveInt(strictSeat(facts, 'count'));
+    if (count === undefined)
+        return undefined;
+    const nothing = Object.freeze({ redeliver: Object.freeze([]), askUser: Object.freeze([]), unattributed: count });
+    if (strictSeat(facts, 'cause') !== 'leg_end' || strictSeat(facts, 'childSessionId') !== undefined)
+        return nothing;
+    const ids = exactInputIdList(strictSeat(facts, 'inputIds'), count);
+    if (ids === undefined)
+        return nothing;
+    if (ledger !== null && ledger !== undefined && typeof ledger !== 'object')
+        return nothing;
+    const l = ledger ?? {};
+    const handed = ledgerIdSet(l, 'handed');
+    const redelivered = ledgerIdSet(l, 'redelivered');
+    if (handed === UNREADABLE || redelivered === UNREADABLE)
+        return nothing;
+    const redeliver = [];
+    const askUser = [];
+    for (const id of ids) {
+        if (redelivered.has(id))
+            askUser.push(id);
+        else if (handed.has(id))
+            redeliver.push(id);
+    }
+    return Object.freeze({ redeliver: Object.freeze(redeliver), askUser: Object.freeze(askUser), unattributed: count - redeliver.length - askUser.length });
+}
 const messagesPhrase = (n, noun) => `${n} ${noun}${n === 1 ? '' : 's'}`;
 const verbBe = (n) => (n === 1 ? 'was' : 'were');
 const itThem = (n) => (n === 1 ? 'it' : 'them');
@@ -904,18 +1005,27 @@ function readContextMediaRemovedOf(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
     const n = notice;
-    if (ownSeat(n, 'code') !== 'context.media_removed')
+    const code = ownSeat(n, 'code');
+    if (code !== 'context.media_removed' && code !== 'context.image_removed')
         return undefined;
     const d = ownSeat(n, 'detail');
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
+    const count = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+    if (code === 'context.image_removed') {
+        const legacyImages = ownSeat(o, 'images');
+        const legacySessionId = nonEmpty(ownSeat(o, 'sessionId'));
+        const legacyRunId = nonEmpty(ownSeat(o, 'runId'));
+        if (!count(legacyImages) || legacyImages < 1 || legacySessionId === undefined || legacyRunId === undefined)
+            return undefined;
+        return { reason: 'rejected_by_provider', images: legacyImages, documents: 0, sessionId: legacySessionId, runId: legacyRunId };
+    }
     const reason = nonEmpty(ownSeat(o, 'reason'));
     const images = ownSeat(o, 'images');
     const documents = ownSeat(o, 'documents');
     const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
     const runId = nonEmpty(ownSeat(o, 'runId'));
-    const count = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
     if (reason === undefined || !count(images) || !count(documents) || images + documents < 1 || sessionId === undefined || runId === undefined)
         return undefined;
     return { reason, images, documents, sessionId, runId };
@@ -1009,6 +1119,7 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'route.stream_end_ignored': readStreamEndIgnored,
     'mcp.authorization_required': readMcpAuthorizationRequired,
     'context.media_removed': readContextMediaRemoved,
+    'context.image_removed': readContextMediaRemoved,
     'session.lineage_rerooted': readSessionLineageRerooted,
 });
 const _factReaderTablePin = true;

package/dist/errorSupplementRoles.js

@@ -5,7 +5,7 @@ import { resumeReopenContent } from './hitl/suspendedReopen.js';
 import { idempotencyPayloadMismatchContent } from './engineErrorCodes.js';
 import { inheritEnvRefusalContent } from './inheritEnvWire.js';
 import { projectSeedRefusalContent } from './projectSeed.js';
-import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
+import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, sessionArchiveStampedContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
 const ROLE_BY_READER = new Map([
     [corruptSessionContent, 'replacement'],
     [corruptStoredRowContent, 'replacement'],
@@ -19,6 +19,7 @@ const ROLE_BY_READER = new Map([
     [settingsPermissionBucketRefusalContent, 'replacement'],
     [fieldLimitRefusalContent, 'replacement'],
     [autonomyLaneRefusalContent, 'replacement'],
+    [sessionArchiveStampedContent, 'replacement'],
     [idempotencyPayloadMismatchContent, 'replacement'],
     [unsupportedRuleRefusalContent, 'replacement'],
     [projectSeedRefusalContent, 'replacement'],

package/dist/executionLaneCapability.js

@@ -2,6 +2,7 @@ import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
+import { executionLaneWordIsNone } from './executionLaneWords.js';
 export function projectExecutionLaneCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object')
@@ -100,8 +101,8 @@ export function executionLaneDoctorDetail(reading) {
             if (reading.view.toolsOnThisHost) {
                 return `execution lane ${lane} — tools run on the engine host (same filesystem), so skills that have a directory of their own can carry a baseDir`;
             }
-            if (reading.view.provider === 'in-process') {
-                return 'no execution lane on this deployment (in-process) — the engine has no machine of its own for running tools here, so its built-in file and shell tools are not mounted and skill baseDir is never sent; whether a given run had tools is answered by its tool roster';
+            if (executionLaneWordIsNone(reading.view.provider)) {
+                return `no execution lane on this deployment (${lane}) — the engine has no machine of its own for running tools here, so its built-in file and shell tools are not mounted and skill baseDir is never sent; whether a given run had tools is answered by its tool roster`;
             }
             return `execution lane ${lane} — tools run on a different machine than the engine, so skill baseDir is never sent on this deployment`;
         }

package/dist/executionLaneWords.d.ts

@@ -0,0 +1 @@
+export declare function executionLaneWordIsNone(provider: string): boolean;

package/dist/executionLaneWords.js

@@ -0,0 +1,3 @@
+export function executionLaneWordIsNone(provider) {
+    return provider === 'none' || provider === 'in-process';
+}

package/dist/generated/engineNoticeTables.js

@@ -51,6 +51,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "checkpoint.execution_outcome_unrecorded",
     "delegation.transcript_integrity",
     "delegation.ask_unresolvable",
+    "delegation.resume_lane_missing",
     "mcp.injection_dropped",
     "mcp.revocation_probe_failed",
     "mcp.server_redialed",
@@ -60,6 +61,8 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "workflow.agent_option_ignored",
     "memory.session_polluted",
     "memory.harvest_quarantined",
+    "memory.harvest_refused",
+    "memory.harvest_conflict",
     "memory.delegation_static_mark_waived",
     "memory.content_class_declared",
     "memory.hold_opened",
@@ -110,7 +113,6 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "fs.staging_file_swept",
     "session.lineage_rerooted",
     "instructions.source_changed",
-    "session.records_skipped",
     "memory.layer_locked_legacy",
     "server.model_unreachable",
     "permission.entry_mode_clamped",
@@ -168,6 +170,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "checkpoint.execution_outcome_unrecorded": "operator",
     "delegation.transcript_integrity": "operator",
     "delegation.ask_unresolvable": "user",
+    "delegation.resume_lane_missing": "operator",
     "mcp.injection_dropped": "user",
     "mcp.revocation_probe_failed": "operator",
     "mcp.server_redialed": "operator",
@@ -177,6 +180,8 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "workflow.agent_option_ignored": "operator",
     "memory.session_polluted": "user",
     "memory.harvest_quarantined": "user",
+    "memory.harvest_refused": "user",
+    "memory.harvest_conflict": "user",
     "memory.delegation_static_mark_waived": "user",
     "memory.content_class_declared": "operator",
     "memory.hold_opened": "user",
@@ -227,7 +232,6 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "fs.staging_file_swept": "operator",
     "session.lineage_rerooted": "user",
     "instructions.source_changed": "user",
-    "session.records_skipped": "user",
     "memory.layer_locked_legacy": "operator",
     "server.model_unreachable": "user",
     "permission.entry_mode_clamped": "user",
@@ -291,6 +295,7 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "checkpoint.execution_outcome_unrecorded": "engine",
     "delegation.transcript_integrity": "engine",
     "delegation.ask_unresolvable": "engine",
+    "delegation.resume_lane_missing": "engine",
     "mcp.injection_dropped": "engine",
     "mcp.revocation_probe_failed": "engine",
     "mcp.server_redialed": "engine",
@@ -300,6 +305,8 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "workflow.agent_option_ignored": "engine",
     "memory.session_polluted": "engine",
     "memory.harvest_quarantined": "engine",
+    "memory.harvest_refused": "engine",
+    "memory.harvest_conflict": "engine",
     "memory.delegation_static_mark_waived": "engine",
     "memory.content_class_declared": "engine",
     "memory.hold_opened": "engine",
@@ -350,7 +357,6 @@ export const CORE_NOTICE_MINTER = Object.freeze({
     "fs.staging_file_swept": "engine",
     "session.lineage_rerooted": "engine",
     "instructions.source_changed": "server",
-    "session.records_skipped": "server",
     "memory.layer_locked_legacy": "server",
     "server.model_unreachable": "server",
     "permission.entry_mode_clamped": "server",

package/dist/hitl/approvalResolution.d.ts

@@ -4,9 +4,10 @@ import type { AskAnsweredOutput } from './gateLedger.js';
 import type { ApprovalDenySettledBy, ToolApprovalRespondAckView, ToolApprovalRespondDecision, ToolApprovalRespondParkingView } from './toolApprovalWire.js';
 import { type DecisionRefusalReading, type RefusalRouteContext } from './decisionRefusal.js';
 import { type DeliveredReading, type LadderSafetyStop } from './attributionLadder.js';
+import { type CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 export declare const APPROVAL_RESOLUTION_LANES: readonly ["respond", "decide", "ask"];
 export type ApprovalResolutionLane = (typeof APPROVAL_RESOLUTION_LANES)[number];
-export declare const APPROVAL_NOT_SENT_CAUSES: readonly ["retracted", "edit_refused", "no_pending", "wrong_gate", "fetch_failed", "no_input", "card_unavailable", "safety_stop"];
+export declare const APPROVAL_NOT_SENT_CAUSES: readonly ["retracted", "edit_refused", "no_pending", "wrong_gate", "fetch_failed", "no_input", "card_unavailable", "safety_stop", "row_unresumable"];
 export type ApprovalNotSentCause = (typeof APPROVAL_NOT_SENT_CAUSES)[number];
 export declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "engine_error", "no_answer", "transport_exhausted", "parking_in_progress", "interrupted", "orchestration", "unreadable"];
 export type ApprovalUnsettledCause = (typeof APPROVAL_UNSETTLED_CAUSES)[number];
@@ -32,6 +33,9 @@ export interface ApprovalResolutionNotSent extends ApprovalResolutionBase {
     readonly kind: 'not_sent';
     readonly cause: ApprovalNotSentCause;
     readonly safetyCode?: Exclude<HitlSafetyCode, 'binding_mismatch' | 'no_pending' | 'wrong_gate'>;
+    readonly rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
     readonly detail?: string;
 }
 export interface ApprovalResolutionUnsettled extends ApprovalResolutionBase {

package/dist/hitl/approvalResolution.js

@@ -4,6 +4,8 @@ import { isSlotCarrier, thrownIsInstanceOf } from '../wireFailureShape.js';
 import { carrierReadOf, isLocalSafetyStop, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
 import { directFailureReadingOf, transportReadingOf } from './approvalDelivery.js';
 import { ownReadingSlot } from '../engineWireFor.js';
+import { CHECKPOINT_ROW_BAR_SENTENCE } from '../checkpointRowVerdict.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const APPROVAL_RESOLUTION_LANES = Object.freeze(['respond', 'decide', 'ask']);
 export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'retracted',
@@ -14,6 +16,7 @@ export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'no_input',
     'card_unavailable',
     'safety_stop',
+    'row_unresumable',
 ]);
 export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'engine_refused',
@@ -49,6 +52,7 @@ const NOT_SENT_SENTENCES = Object.freeze({
     no_input: 'the approval has no tool input or question to show, so no card was shown; nothing was sent',
     card_unavailable: 'no approval card could be shown on this host; nothing was sent',
     safety_stop: 'the decision was stopped by a local safety check before it was sent; nothing was sent',
+    row_unresumable: CHECKPOINT_ROW_BAR_SENTENCE,
 });
 function nonEmpty(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -77,8 +81,21 @@ export function approvalResolutionDetail(r) {
         if (cause === undefined || !Object.hasOwn(NOT_SENT_SENTENCES, cause))
             return undefined;
         const sentence = NOT_SENT_SENTENCES[cause];
+        if (cause === 'row_unresumable') {
+            let verdict;
+            try {
+                const d = Object.getOwnPropertyDescriptor(r, 'rowVerdict');
+                verdict = d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+            }
+            catch {
+                verdict = undefined;
+            }
+            return ownStr(verdict, 'kind') !== 'unreadable' ? (ownStr(verdict, 'sentence') ?? sentence) : sentence;
+        }
         const code = cause === 'safety_stop' ? ownStr(r, 'safetyCode') : undefined;
-        return code !== undefined ? `${sentence} (${code})` : sentence;
+        if (code === undefined)
+            return sentence;
+        return code === 'binding_missing' ? `${sentence} (${code}) · ${renderMessage(msg('approval.decide.unboundWayOut'))}` : `${sentence} (${code})`;
     }
     if (kind !== 'unsettled')
         return undefined;

package/dist/hitl/approvalsFeed.js

@@ -3,6 +3,7 @@ import { unrefTimer } from '../unrefTimer.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
 import { approvalQueueRowFamilyOf, peerInboundQueueRowOf } from './approvalQueueRow.js';
+import { parkRowDelegationLinksOf } from './parkRowDelegation.js';
 import { checkpointRowVerdictOf } from '../checkpointRowVerdict.js';
 const _realClientFitsFeedSlice = true;
 void _realClientFitsFeedSlice;
@@ -49,7 +50,7 @@ function readDurablePendingRows(raw) {
 }
 function durableDigestOf(rows) {
     return rows
-        .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '', JSON.stringify(checkpointRowVerdictOf(r) ?? null)]
+        .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '', JSON.stringify(checkpointRowVerdictOf(r) ?? null), JSON.stringify(parkRowDelegationLinksOf(r) ?? null)]
         .join('
'))
         .sort()
         .join('');

package/dist/hitl/askParkRowRouting.js

@@ -3,6 +3,8 @@ import { isAskTool, questionCardVerdict } from './frameRouter.js';
 import { approvalCallKey } from './gateIdentity.js';
 import { askQuestionsFromPending, pendingRowIsOwnedByThisSession } from './parkOwnership.js';
 import { approvalQueueRowFamilyOf, checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
+import { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const ASK_PARK_ROW_WAIT_MS = 15000;
 export const ASK_PARK_ROW_POLL_MS = 500;
 export function classifyAskParkRows(queueRows, taskId, deps) {
@@ -29,6 +31,14 @@ export function classifyAskParkRows(queueRows, taskId, deps) {
         };
     }
     const foreignKind = familyUnreadable.has(pending) ? QUEUE_ROW_FAMILY_UNREADABLE_GATE : askParkForeignGateKind(pending);
+    const bar = foreignKind === null || foreignKind === QUEUE_ROW_FAMILY_UNREADABLE_GATE ? checkpointRowBarOf(pending) : undefined;
+    if (bar !== undefined) {
+        return {
+            kind: 'settled',
+            reason: renderMessage(msg('approval.rowUnresumable.askNotSurfaced', { taskId: String(pending.taskId), sentence: checkpointRowBarSentence(bar) })),
+            rowVerdict: bar,
+        };
+    }
     if (foreignKind !== null) {
         return {
             kind: 'unborn',
@@ -129,6 +139,8 @@ export function pendingRowIsOwnedAndDecidable(row, deps) {
         return true;
     if (leg !== 'approval')
         return false;
+    if (checkpointRowBarOf(row) !== undefined)
+        return false;
     return askParkRowArm(row) === 'question' ? askQuestionsFromPending(row) !== null : true;
 }
 export function countOwnedPendingRows(listed, deps) {

package/dist/hitl/decisionSend.d.ts

@@ -20,6 +20,7 @@ export interface HitlApprovalDecisionRequest {
     readonly taskId?: string;
     readonly toolCallId?: string;
     readonly answer: ApprovalCardDecision;
+    readonly card?: object;
 }
 export interface HitlAskDecisionRequest {
     readonly family: 'ask';
@@ -28,6 +29,7 @@ export interface HitlAskDecisionRequest {
     readonly approvalId?: string;
     readonly toolCallId?: string;
     readonly answer: ApprovalCardDecision;
+    readonly card?: object;
 }
 export interface HitlElicitationDecisionRequest {
     readonly family: 'elicitation';

package/dist/hitl/decisionSend.js

@@ -10,7 +10,7 @@ import { readDecisionNoteAudit } from './approvalDecisionNoteAudit.js';
 import { carrierReadOf, deliverWithAttributionLadder, isLocalSafetyStop } from './attributionLadder.js';
 import { budgetSpent, deliverApprovalDecision, deliveryTiming, isAborted, newSendTally, PARKING_WAIT_CAP_MS, setDeliveryTimingForTests, sleepFor, settledTransportReadingOf, withTransportRetry, deliveryReadingOf, } from './approvalDelivery.js';
 import { ASK_DECIDED_CODE, classifyDeliveredDecisionRefusal, decisionRefusalClosesOut, notPendingAfterRetry } from './decisionRefusal.js';
-import { sessionAllowCarried } from './sessionAllowRoute.js';
+import { sessionAllowEligible } from './sessionAllowRoute.js';
 import { addDecisionOpKeys, closeDecisionOp, decisionLedgerKeysOf, decisionOpsWithKey, openDecisionOp } from './decisionLedger.js';
 import { hostHoldIsActive, takeHostHoldLedgerOp, tryHoldApprovalNow } from './approvalHolds.js';
 import { answerPayloadFor, decisionAttributionKeyOf, isToolApprovalRespondReplayed, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, } from './toolApprovalWire.js';
@@ -195,7 +195,7 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
     if (payload === undefined)
         return { family: 'ask', attempts: ctx.tally.attempts, kind: 'not_sent', cause: 'not_an_answer' };
     let fallbackRespond = respondForFallback;
-    if (req.answer.kind === 'allow' && req.answer.allowSession === true && respondForFallback !== undefined && req.approvalId !== undefined && sessionAllowCarried('v1', req.approvalId)) {
+    if (req.answer.kind === 'allow' && req.answer.allowSession === true && respondForFallback !== undefined && req.approvalId !== undefined) {
         const viaAnswerGate = await sendApprovalFamily(respondForFallback, req.approvalId, req.answer, ctx);
         if (!answerGateCannotTake(viaAnswerGate))
             return { ...viaAnswerGate, family: 'ask', allowSessionCarried: true };
@@ -386,6 +386,14 @@ function snapshotAnswer(raw) {
     }
     return typeof kind === 'string' ? Object.freeze({ kind }) : undefined;
 }
+function sessionGatedAnswer(answer, card) {
+    if (answer.kind !== 'allow' || answer.allowSession !== true)
+        return { answer };
+    const why = card === undefined ? 'card_absent' : typeof card === 'object' && card !== null ? sessionAllowEligible(card) : 'card_unreadable';
+    if (why === 'given')
+        return { answer };
+    return { answer: Object.freeze({ ...answer, allowSession: false }), dropped: why };
+}
 function readRequest(req) {
     if (typeof req !== 'object' || req === null)
         return undefined;
@@ -399,17 +407,19 @@ function readRequest(req) {
     const rawAnswer = guardedRead(() => readOwnDataValue(req, 'answer'));
     if (typeof rawAnswer !== 'object' || rawAnswer === null)
         return undefined;
-    const answer = snapshotAnswer(rawAnswer);
-    if (answer === undefined)
+    const snapshot = snapshotAnswer(rawAnswer);
+    if (snapshot === undefined)
         return undefined;
+    const { answer, dropped } = sessionGatedAnswer(snapshot, guardedRead(() => readOwnDataValue(req, 'card')));
+    const droppedFact = dropped !== undefined ? { sessionAllowDropped: dropped } : {};
     if (family === 'approval') {
         const approvalId = s('approvalId');
-        return approvalId !== undefined ? { family, approvalId, taskId: s('taskId'), toolCallId: s('toolCallId'), answer } : undefined;
+        return approvalId !== undefined ? { family, approvalId, taskId: s('taskId'), toolCallId: s('toolCallId'), answer, ...droppedFact } : undefined;
     }
     if (family === 'ask') {
         const taskId = s('taskId');
         const askId = s('askId');
-        return taskId !== undefined && askId !== undefined ? { family, taskId, askId, approvalId: s('approvalId'), toolCallId: s('toolCallId'), answer } : undefined;
+        return taskId !== undefined && askId !== undefined ? { family, taskId, askId, approvalId: s('approvalId'), toolCallId: s('toolCallId'), answer, ...droppedFact } : undefined;
     }
     return undefined;
 }
@@ -519,6 +529,10 @@ export async function sendHitlDecision(request, deps) {
                 out = outcomeOfThrown(e, 'elicitation', undefined, signal, ctx.tally, false);
             }
         }
+        if (req.family !== 'elicitation' && req.sessionAllowDropped !== undefined) {
+            hostLog('debug', `decisionSend: session-allow-not-eligible ${req.family}=${req.family === 'ask' ? req.askId : req.approvalId} why=${req.sessionAllowDropped} via=allow-once`);
+            out = { ...out, rememberDropped: true };
+        }
         const ambiguous = out.kind === 'unconfirmed' || (out.kind === 'not_applied' && (out.cause === 'parking' || out.cause === 'refused' || out.cause === 'idempotency_crossed'));
         if (ambiguous && out.cause !== 'aborted') {
             const gate = req.family === 'elicitation'

package/dist/hitl/hitlBridge.d.ts

@@ -3,6 +3,7 @@ import type { PermissionResult } from '@sema-agent/agent-types';
 import { type CapturedLocalCode, type CauseSlotRead } from '../engineWireFor.js';
 import type { ApprovalsListEnvelope } from './crashConverged.js';
 import { type SuspendedReopenReading } from './suspendedReopen.js';
+import type { CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 export declare const DEFAULT_DENY_REASON = "The user rejected this tool use";
 export declare const MAX_DENY_REASON_CHARS = 4096;
 export declare function denyReasonForWire(reason: string | undefined, tag: string): string | undefined;
@@ -132,7 +133,10 @@ export type FindPendingOutcome = {
 } | {
     ok: false;
     reason: string;
-    code?: 'no_pending' | 'wrong_gate';
+    code?: 'no_pending' | 'wrong_gate' | 'row_unresumable';
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 };
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;

package/dist/hitl/hitlBridge.js

@@ -11,6 +11,8 @@ import { suspendedReopenOf } from './suspendedReopen.js';
 import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisionLedger.js';
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
+import { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -283,6 +285,9 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         ? readings.find((x) => x.r.taskId === taskId && (x.r.boundCallId === callId || x.r.toolCallId === callId) && x.foreign !== null)
         : undefined;
     if (identityForeign !== undefined) {
+        const identityBar = identityForeign.foreign === QUEUE_ROW_FAMILY_UNREADABLE_GATE ? checkpointRowBarOf(identityForeign.r) : undefined;
+        if (identityBar !== undefined)
+            return { ok: false, reason: checkpointRowBarSentence(identityBar), code: 'row_unresumable', rowVerdict: identityBar };
         return {
             ok: false,
             reason: `the pending row this park names (call ${callId}) is parked on a '${String(identityForeign.foreign)}' gate — not an approval this leg decides; refusing to decide a different row`,
@@ -294,8 +299,19 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
     const pending = (identityConflicts ? undefined : identityRow) ??
         pool.find((r) => r.taskId === taskId && matches(typeof r.toolName === 'string' ? r.toolName : undefined)) ??
         pool.find((r) => r.taskId === taskId);
-    if (!pending)
+    if (!pending) {
+        for (const x of readings) {
+            if (x.r.taskId !== taskId || x.foreign !== QUEUE_ROW_FAMILY_UNREADABLE_GATE)
+                continue;
+            const unreadableBar = checkpointRowBarOf(x.r);
+            if (unreadableBar !== undefined)
+                return { ok: false, reason: checkpointRowBarSentence(unreadableBar), code: 'row_unresumable', rowVerdict: unreadableBar };
+        }
         return { ok: false, reason: 'no pending checkpoint for this run (resolved/expired?)', code: 'no_pending' };
+    }
+    const bar = checkpointRowBarOf(pending);
+    if (bar !== undefined)
+        return { ok: false, reason: checkpointRowBarSentence(bar), code: 'row_unresumable', rowVerdict: bar };
     return { ok: true, pending, gatedCallId: pending.toolCallId ?? pending.boundCallId ?? undefined };
 }
 export class HitlBridge {
@@ -349,7 +365,7 @@ export class HitlBridge {
         if (typeof boundCallId !== 'string' || boundCallId.length === 0 || typeof boundInputHash !== 'string' || boundInputHash.length === 0) {
             throw new HitlSafetyError(`pending checkpoint ${p.id ?? '<no-id>'} is missing D-1 binding fields ` +
                 `(boundCallId=${String(boundCallId)}, boundInputHash=${String(boundInputHash)}) — ` +
-                'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_missing');
+                `the row itself carries no binding to echo, so ${renderMessage(msg('approval.decide.unboundWayOut'))}`, 'binding_missing');
         }
         return { boundCallId, boundInputHash };
     }
@@ -358,6 +374,8 @@ export class HitlBridge {
         if (!pending) {
             throw new HitlSafetyError('no pending checkpoint to decide (resolved/expired under the human) — refetch + re-present', 'no_pending');
         }
+        if (preResolvedPending !== undefined)
+            assertPendingRowResumable(preResolvedPending);
         const decision = outcome.decision === 'approve'
             ? {
                 decision: 'approve',
@@ -383,6 +401,8 @@ export class HitlBridge {
         if (!pending) {
             throw new HitlSafetyError('no pending AskUserQuestion checkpoint to answer — refetch + re-present', 'no_pending');
         }
+        if (preResolvedPending !== undefined)
+            assertPendingRowResumable(preResolvedPending);
         const decision = {
             decision: 'approve',
             answer: { answers: answers.map((a) => marshalAnswer(a)) },
@@ -541,6 +561,11 @@ export function makeHitlCanUseTool(bridge, prompt) {
         return decision;
     };
 }
+function assertPendingRowResumable(pending) {
+    const bar = checkpointRowBarOf(pending);
+    if (bar !== undefined)
+        throw new Error(checkpointRowBarSentence(bar));
+}
 function assertAnswersSendable(answers) {
     if (!Array.isArray(answers) || answers.length === 0) {
         throw new HitlSafetyError('refusing to send an EMPTY AskUserQuestion answer set — `{answers:[]}` is the wire\'s DENY/NO_HUMAN form, ' +

package/dist/hitl/livePendingAsk.js

@@ -1,6 +1,7 @@
 import { isApprovalRequestFrameV1 } from '@sema-agent/sdk';
 import { appendOwnElement } from '../ownKey.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
+import { pendingRowIsOfSession } from './parkRowDelegation.js';
 import { approvalLiveFaceOf, liveFaceCarried } from './approvalLiveFace.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from '../wireFailureShape.js';
 import { isToolApprovalFrame, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
@@ -124,7 +125,8 @@ export function countApprovalsAwaitingDecision(snapshot, filter) {
     if (snapshot.kind === 'unknown')
         return { durable: null, live: null, suspendedSubagent: null };
     const bySession = (rows) => scope.kind === 'session' ? rows.filter(r => r.sessionId === scope.sessionId) : [...rows];
-    const durable = (snapshot.pendingDropped ?? 0) > 0 ? null : Array.isArray(snapshot.pending) ? bySession(snapshot.pending).length : null;
+    const durableOfSession = (rows) => scope.kind === 'session' ? rows.filter(r => pendingRowIsOfSession(r, scope.sessionId)).length : rows.length;
+    const durable = (snapshot.pendingDropped ?? 0) > 0 ? null : Array.isArray(snapshot.pending) ? durableOfSession(snapshot.pending) : null;
     if (!Array.isArray(snapshot.livePending))
         return { durable, live: null, suspendedSubagent: null };
     if ((snapshot.livePendingDropped ?? 0) > 0)
@@ -138,7 +140,7 @@ export function livePendingRowToApprovalFrame(row) {
         approvalId: row.approvalId,
         toolName: row.toolName,
         ...(row.fromSubagent === true ? { fromSubagent: true } : {}),
-        ...(row.originTaskId !== undefined ? { sourceTaskId: row.originTaskId } : {}),
+        ...(row.originTaskId !== undefined ? { sourceSessionId: row.originTaskId } : {}),
         ...(row.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(row) ? { requiresRealApproval: true } : {}),
         ...liveFaceCarried(approvalLiveFaceOf(row)),