@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/generated/settingsSchemaSafetyMergeSpec.js

@@ -53,7 +53,7 @@ export const SETTINGS_SAFETY_MERGE_CLOSURE = (MIN_TRUST_WORDS) => {
         model: { mergeShape: "replace", minTrust: "session", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "RoleSpec / TaskSpec.{model,thinking}" },
         env: { mergeShape: "concat", minTrust: "project", tighten: { rule: "none" }, enforcement: "resolver", fail: "open", seam: "NodeExecutionEnv.shellEnv (later layer overrides same name)" },
         envSecret: { mergeShape: "replace", minTrust: "global", tighten: { rule: "none" }, enforcement: "resolver", fail: "closed", seam: "§7 secret-ref resolution" },
-        memoryScopes: { mergeShape: "concat", minTrust: "global", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "MemoryStore" },
+        memoryScopes: { mergeShape: "concat", minTrust: "global", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "MemoryEngine" },
         autoCompaction: { mergeShape: "replace", minTrust: "session", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "compaction config" },
         ui: { mergeShape: "replace", minTrust: "local", tighten: { rule: "none" }, enforcement: "client", fail: "open", seam: "shell-only (theme/keybindings/statusLine) — never touches the engine" },
         org: { mergeShape: "replace", minTrust: "managed", tighten: { rule: "none" }, enforcement: "server", fail: "closed", seam: "web-admin → governanceBaseline (SSO/SCIM/audit/budget, TOB-only)" },

package/dist/generated/settingsSchemaSettingsSources.d.ts

@@ -1 +1 @@
-export declare const SETTINGS_LAYER_SOURCES_CLOSURE: (SAFETY_MERGE_SPEC: object, isAtLeast: (layer: string, minTrust: string) => boolean, memberAdmission: (category: string, member: string) => object) => any;
+export declare const SETTINGS_LAYER_SOURCES_CLOSURE: (SAFETY_MERGE_SPEC: object, isAtLeast: (layer: string, minTrust: string) => boolean, memberAdmission: (category: string, member: string) => object, echoCallerText: (text: string) => string, stripControlAndBidi: (text: string) => string) => any;

package/dist/generated/settingsSchemaSettingsSources.js

@@ -1,4 +1,4 @@
-export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, memberAdmission) => {
+export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, memberAdmission, echoCallerText, stripControlAndBidi) => {
     const SETTINGS_SOURCES = ["userSettings", "projectSettings", "localSettings", "flagSettings", "policySettings", "foreignProjectSettings"];
     const SETTINGS_SOURCE_CONTRACT = {
         userSettings: { trust: "global", repoControllable: false },
@@ -41,6 +41,26 @@ export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, mem
         const accepted = workspaceAccepted(workspace);
         return layer.tightenOnly === true || (layer.repoControllable && !accepted);
     }
+    const LAYER_PARTS_UNREAD_CODE = "settings.layer_parts_unread";
+    const NOTICE_PARTS_SHOWN = 16;
+    function buildLayerPartsUnreadNotice(input) {
+        const layer = settingsSourceContract(input.source);
+        if (!readsTightenOnly(layer, input.workspace)) {
+            throw new RangeError(`buildLayerPartsUnreadNotice: source '${input.source}' is not read in the tighten direction only under workspace reading '${input.workspace}' — there is nothing "read for restrictions only" to disclose`);
+        }
+        if (input.parts.length === 0)
+            return undefined;
+        const cause = layer.tightenOnly === true ? "it is written for another tool" : "this workspace is not trusted";
+        const shown = input.parts.slice(0, NOTICE_PARTS_SHOWN).map(echoCallerText);
+        const rest = input.parts.length - shown.length;
+        const named = rest > 0 ? `${shown.join(", ")}, +${rest} more` : shown.join(", ");
+        return {
+            code: LAYER_PARTS_UNREAD_CODE,
+            source: input.source,
+            parts: [...input.parts],
+            line: `${stripControlAndBidi(input.file)}: read for restrictions only (${cause}) — not read: ${named}`,
+        };
+    }
     function workspaceAccepted(workspace) {
         switch (workspace) {
             case "accepted":
@@ -54,5 +74,5 @@ export const SETTINGS_LAYER_SOURCES_CLOSURE = (SAFETY_MERGE_SPEC, isAtLeast, mem
             }
         }
     }
-    return { layerAdmission };
+    return { layerAdmission, buildLayerPartsUnreadNotice };
 };

package/dist/hitl/approvalLiveFace.d.ts

@@ -0,0 +1,17 @@
+import type { ApprovalMandateWord } from '../gateVocabulary.js';
+export declare const APPROVAL_LIVE_FACE_KEYS: readonly ["mandate", "mandated", "origin"];
+export declare function hasOwnStrictTrue(v: object, key: string): boolean;
+export interface ApprovalLiveFaceFacts {
+    mandated?: true;
+    mandate?: ApprovalMandateWord;
+    origin?: string;
+}
+export interface ApprovalLiveFace {
+    readonly facts: Readonly<ApprovalLiveFaceFacts>;
+    readonly layerUnknown?: 'marked' | 'absent';
+}
+export declare function approvalLiveFaceOf(live: object): ApprovalLiveFace;
+export type ApprovalLiveFaceCarried = ApprovalLiveFaceFacts & {
+    readonly liveFactsUnknown?: true;
+};
+export declare function liveFaceCarried(face: ApprovalLiveFace): ApprovalLiveFaceCarried;

package/dist/hitl/approvalLiveFace.js

@@ -0,0 +1,35 @@
+import { readAskOrigin } from '../ownKey.js';
+import { slotPresenceOf, slotReadOf } from '../wireFailureShape.js';
+import { readApprovalMandate } from './toolApprovalWire.js';
+export const APPROVAL_LIVE_FACE_KEYS = Object.freeze(['mandate', 'mandated', 'origin']);
+export function hasOwnStrictTrue(v, key) {
+    return Object.hasOwn(v, key) && v[key] === true;
+}
+const APPROVAL_LIVE_FACTS_UNKNOWN_KEY = 'liveFactsUnknown';
+function guarded(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalLiveFaceOf(live) {
+    const marker = slotReadOf(live, APPROVAL_LIVE_FACTS_UNKNOWN_KEY);
+    const marked = marker.presence === 'unreadable' || (marker.presence === 'present' && marker.value === true);
+    const layerAbsent = !marked && APPROVAL_LIVE_FACE_KEYS.every((k) => slotPresenceOf(live, k) === 'absent');
+    const facts = {};
+    if (guarded(() => hasOwnStrictTrue(live, 'mandated')) === true)
+        facts.mandated = true;
+    const mandate = guarded(() => readApprovalMandate(live));
+    if (mandate !== undefined)
+        facts.mandate = mandate;
+    const origin = guarded(() => readAskOrigin(live));
+    if (origin !== undefined)
+        facts.origin = origin;
+    const layerUnknown = marked ? 'marked' : layerAbsent ? 'absent' : undefined;
+    return Object.freeze({ facts: Object.freeze(facts), ...(layerUnknown !== undefined ? { layerUnknown } : {}) });
+}
+export function liveFaceCarried(face) {
+    return face.layerUnknown === 'marked' ? { ...face.facts, [APPROVAL_LIVE_FACTS_UNKNOWN_KEY]: true } : { ...face.facts };
+}

package/dist/hitl/approvalQueueRow.d.ts

@@ -0,0 +1,21 @@
+import { SDK_APPROVAL_QUEUE_KINDS } from '../generated/sdkFactTables.js';
+export type ApprovalQueueKind = (typeof SDK_APPROVAL_QUEUE_KINDS)[number];
+export type ApprovalQueueRowFamily = ApprovalQueueKind | 'unknown' | 'unreadable';
+export declare function approvalQueueRowFamilyOf(row: object): ApprovalQueueRowFamily;
+export type CheckpointQueueRowSort = 'checkpoint' | 'excluded' | 'unreadable';
+export declare function checkpointQueueRowSortOf(row: object | null | undefined): CheckpointQueueRowSort;
+export declare const QUEUE_ROW_FAMILY_UNREADABLE_GATE = "(unreadable)";
+export interface ApprovalQueuePeerInboundRow {
+    readonly id: string;
+    readonly recipientSessionId: string;
+    readonly lane?: string;
+    readonly cause?: string;
+    readonly content?: string;
+    readonly sentAt?: number;
+    readonly heldAt?: number;
+    readonly deadline?: number;
+    readonly fromSession?: string;
+    readonly fromName?: string;
+    readonly fromScope?: string;
+}
+export declare function peerInboundQueueRowOf(row: object): ApprovalQueuePeerInboundRow | undefined;

package/dist/hitl/approvalQueueRow.js

@@ -0,0 +1,69 @@
+import { slotReadOf } from '../wireFailureShape.js';
+import { SDK_APPROVAL_QUEUE_KINDS } from '../generated/sdkFactTables.js';
+const _queueKindsPin = true;
+void _queueKindsPin;
+const isApprovalQueueKind = (v) => SDK_APPROVAL_QUEUE_KINDS.includes(v);
+export function approvalQueueRowFamilyOf(row) {
+    const kind = slotReadOf(row, 'kind');
+    if (kind.presence === 'absent')
+        return 'checkpoint';
+    if (kind.presence !== 'present' || typeof kind.value !== 'string')
+        return 'unreadable';
+    return isApprovalQueueKind(kind.value) ? kind.value : 'unknown';
+}
+export function checkpointQueueRowSortOf(row) {
+    try {
+        if (typeof row !== 'object' || row === null || Array.isArray(row))
+            return 'excluded';
+        const family = approvalQueueRowFamilyOf(row);
+        return family === 'checkpoint' ? 'checkpoint' : family === 'unreadable' ? 'unreadable' : 'excluded';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export const QUEUE_ROW_FAMILY_UNREADABLE_GATE = '(unreadable)';
+const ownString = (row, key, nonEmpty) => {
+    const r = slotReadOf(row, key);
+    return r.presence === 'present' && typeof r.value === 'string' && (!nonEmpty || r.value !== '') ? r.value : undefined;
+};
+const ownTime = (row, key) => {
+    const r = slotReadOf(row, key);
+    return r.presence === 'present' && typeof r.value === 'number' && Number.isFinite(r.value) && r.value >= 0 ? r.value : undefined;
+};
+export function peerInboundQueueRowOf(row) {
+    try {
+        const id = ownString(row, 'id', true);
+        const recipientSessionId = ownString(row, 'recipientSessionId', true);
+        if (id === undefined || recipientSessionId === undefined)
+            return undefined;
+        const out = { id, recipientSessionId };
+        const lane = ownString(row, 'lane', true);
+        if (lane !== undefined)
+            out.lane = lane;
+        const cause = ownString(row, 'cause', true);
+        if (cause !== undefined)
+            out.cause = cause;
+        const content = ownString(row, 'content', false);
+        if (content !== undefined)
+            out.content = content;
+        const sentAt = ownTime(row, 'sentAt');
+        if (sentAt !== undefined)
+            out.sentAt = sentAt;
+        const heldAt = ownTime(row, 'heldAt');
+        if (heldAt !== undefined)
+            out.heldAt = heldAt;
+        const deadline = ownTime(row, 'deadline');
+        if (deadline !== undefined)
+            out.deadline = deadline;
+        for (const k of ['fromSession', 'fromName', 'fromScope']) {
+            const v = ownString(row, k, true);
+            if (v !== undefined)
+                out[k] = v;
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}

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.d.ts

@@ -1,13 +1,13 @@
 import type { PendingCheckpoint } from '@sema-agent/sdk';
 import { type LivePendingAskView } from './livePendingAsk.js';
+import { type ApprovalQueuePeerInboundRow } from './approvalQueueRow.js';
+import type { ApprovalsListEnvelope } from './crashConverged.js';
+export type { ApprovalQueuePeerInboundRow } from './approvalQueueRow.js';
 export interface ApprovalsFeedClientLike {
     approvals: {
         list(opts?: {
             signal?: AbortSignal;
-        }): Promise<{
-            pending: PendingCheckpoint[];
-            livePending?: unknown[];
-        }>;
+        }): Promise<ApprovalsListEnvelope>;
         stream?(opts?: {
             signal?: AbortSignal;
         }): AsyncGenerator<{
@@ -20,6 +20,7 @@ export type ApprovalsFeedMode = 'push' | 'poll' | 'idle';
 export interface ApprovalsFeedSnapshot {
     kind: 'snapshot';
     pending: PendingCheckpoint[];
+    peerInbound?: ApprovalQueuePeerInboundRow[];
     livePending?: LivePendingAskView[];
     livePendingDropped?: number;
     pendingDropped?: number;

package/dist/hitl/approvalsFeed.js

@@ -2,17 +2,41 @@ import { hostLog } from '../host.js';
 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;
 const MAX_CONSECUTIVE_POLL_ESCAPES = 5;
 function readDurablePendingRows(raw) {
     if (!Array.isArray(raw))
         return { kind: 'malformed' };
     const rows = [];
+    const peer = [];
     let dropped = 0;
+    let skipped = 0;
     for (const item of raw) {
         if (item === null || typeof item !== 'object' || Array.isArray(item)) {
             dropped++;
             continue;
         }
+        const family = approvalQueueRowFamilyOf(item);
+        if (family === 'unknown') {
+            skipped++;
+            continue;
+        }
+        if (family === 'peer_inbound') {
+            const view = peerInboundQueueRowOf(item);
+            if (view === undefined)
+                dropped++;
+            else
+                peer.push(view);
+            continue;
+        }
+        if (family === 'unreadable') {
+            dropped++;
+            continue;
+        }
         const sid = item.sessionId;
         if (typeof sid !== 'string' || sid === '') {
             dropped++;
@@ -20,13 +44,13 @@ function readDurablePendingRows(raw) {
         }
         rows.push(item);
     }
-    if (raw.length > 0 && rows.length === 0)
+    if (raw.length > 0 && rows.length + peer.length + skipped === 0)
         return { kind: 'malformed' };
-    return { kind: 'present', rows, dropped };
+    return { kind: 'present', rows, peer, dropped };
 }
 function durableDigestOf(rows) {
     return rows
-        .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '']
+        .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('');
@@ -34,14 +58,20 @@ function durableDigestOf(rows) {
 const LIVE_FIELD_SEP = String.fromCharCode(1);
 const LIVE_ROW_SEP = String.fromCharCode(2);
 const LIVE_SECTION_SEP = String.fromCharCode(3);
-function digestOf(rows, live, dropped = 0, droppedDurable = 0) {
+function peerDigestOf(peer) {
+    return peer
+        .map(r => JSON.stringify(r))
+        .sort()
+        .join(LIVE_ROW_SEP);
+}
+function digestOf(rows, live, dropped = 0, droppedDurable = 0, peer = []) {
     const liveDigest = live === undefined
         ? 'absent'
         : live
             .map(r => [r.approvalId, r.toolName, String(r.expiresAtMs), r.sessionId ?? '', r.originTaskId ?? '', r.frame !== undefined ? 'f' : ''].join(LIVE_FIELD_SEP))
             .sort()
             .join(LIVE_ROW_SEP);
-    return `${durableDigestOf(rows)}${LIVE_SECTION_SEP}${liveDigest}${LIVE_SECTION_SEP}${dropped}${LIVE_SECTION_SEP}${droppedDurable}`;
+    return `${durableDigestOf(rows)}${LIVE_SECTION_SEP}${liveDigest}${LIVE_SECTION_SEP}${dropped}${LIVE_SECTION_SEP}${droppedDurable}${LIVE_SECTION_SEP}${peerDigestOf(peer)}`;
 }
 export function startApprovalsFeed(client, onSnapshot, opts) {
     const pollIntervalMs = opts?.pollIntervalMs ?? 5000;
@@ -158,6 +188,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             return;
         const seq = ++takeSeq;
         let rows;
+        let peer;
         let live;
         let dropped = 0;
         let droppedDurable = 0;
@@ -212,6 +243,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 throw new TypeError('approvalsFeed: unreadable pending section');
             }
             rows = durableRead.rows;
+            peer = durableRead.peer;
             droppedDurable = durableRead.dropped;
             if (durableRead.dropped > 0)
                 hostLog('debug', `approvalsFeed: dropped ${durableRead.dropped} malformed pending row(s) — snapshot carries pendingDropped`);
@@ -220,7 +252,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             return;
         let d;
         try {
-            d = digestOf(rows, live, dropped, droppedDurable);
+            d = digestOf(rows, live, dropped, droppedDurable, peer);
         }
         catch (e) {
             noteTakeMissed(via, seq);
@@ -252,6 +284,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         const snap = {
             kind: 'snapshot',
             pending: rows,
+            ...(peer.length > 0 ? { peerInbound: peer } : {}),
             ...(live !== undefined ? { livePending: live } : {}),
             ...(dropped > 0 ? { livePendingDropped: dropped } : {}),
             ...(droppedDurable > 0 ? { pendingDropped: droppedDurable } : {}),

package/dist/hitl/askParkRowRouting.d.ts

@@ -1,4 +1,5 @@
 import type { PendingCheckpoint } from '@sema-agent/sdk';
+import type { ApprovalQueueRow } from './crashConverged.js';
 import type { ParkRowProbe } from './parkRowBirthWait.js';
 import { type ParkOwnershipDeps } from './parkOwnership.js';
 export declare const ASK_PARK_ROW_WAIT_MS = 15000;
@@ -7,7 +8,7 @@ export interface AskParkRowScanDeps {
     isOwned?: (row: PendingCheckpoint) => boolean;
     ownership?: ParkOwnershipDeps;
 }
-export declare function classifyAskParkRows(rows: readonly PendingCheckpoint[], taskId: string, deps?: AskParkRowScanDeps): ParkRowProbe<PendingCheckpoint>;
+export declare function classifyAskParkRows(queueRows: readonly ApprovalQueueRow[], taskId: string, deps?: AskParkRowScanDeps): ParkRowProbe<PendingCheckpoint>;
 export interface AskParkRowIdentity {
     rowTaskId: string;
     gatedCallId: string | undefined;
@@ -15,7 +16,7 @@ export interface AskParkRowIdentity {
 }
 export declare function askParkRowIdentity(taskId: string, row: PendingCheckpoint): AskParkRowIdentity;
 export declare function askParkRowArm(row: PendingCheckpoint): 'question' | 'tool-gate';
-export declare function askParkRowStillPending(rows: readonly PendingCheckpoint[], identity: AskParkRowIdentity): boolean;
+export declare function askParkRowStillPending(rows: readonly ApprovalQueueRow[], identity: AskParkRowIdentity): boolean;
 export type AskParkChainFailureDisposition = 'retry' | 'row-gone-after-card' | 'row-unborn';
 export declare function classifyAskParkChainFailure(i: {
     rowStillPending: boolean;
@@ -29,6 +30,6 @@ export interface RowArmSingleFlight<T> {
 export declare function createRowArmSingleFlight<T>(): RowArmSingleFlight<T>;
 export declare function pendingRowIsOwnedAndDecidable(row: PendingCheckpoint, deps?: ParkOwnershipDeps): boolean;
 export interface OwnedPendingListView {
-    readonly pending?: readonly PendingCheckpoint[] | null;
+    readonly pending?: readonly ApprovalQueueRow[] | null;
 }
 export declare function countOwnedPendingRows(listed: OwnedPendingListView | null | undefined, deps?: ParkOwnershipDeps): number;

package/dist/hitl/askParkRowRouting.js

@@ -2,10 +2,19 @@ import { askParkForeignGateKind, durableDecideLegOf } from '../adapter/activeRun
 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(rows, taskId, deps) {
+export function classifyAskParkRows(queueRows, taskId, deps) {
     const isOwned = deps?.isOwned ?? ((row) => pendingRowIsOwnedByThisSession(row, deps?.ownership));
+    const sorted = queueRows.flatMap((r) => {
+        const sort = checkpointQueueRowSortOf(r);
+        return sort === 'excluded' ? [] : [{ r: r, unreadable: sort === 'unreadable' }];
+    });
+    const rows = sorted.map((x) => x.r);
+    const familyUnreadable = new Set(sorted.filter((x) => x.unreadable).map((x) => x.r));
     const own = rows.find(r => r.taskId === taskId);
     const sole = rows.length === 1 ? rows[0] : undefined;
     const soleUnowned = sole !== undefined && !isOwned(sole);
@@ -21,7 +30,15 @@ export function classifyAskParkRows(rows, taskId, deps) {
                     : `${String(rows.length)} pending rows but none for task ${taskId} — ambiguous queue, refusing to surface an unrelated row`,
         };
     }
-    const foreignKind = askParkForeignGateKind(pending);
+    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',
@@ -120,7 +137,9 @@ export function pendingRowIsOwnedAndDecidable(row, deps) {
     const leg = durableDecideLegOf(row);
     if (leg === 'plan_review')
         return true;
-    if (leg !== 'approval' && leg !== 'absent')
+    if (leg !== 'approval')
+        return false;
+    if (checkpointRowBarOf(row) !== undefined)
         return false;
     return askParkRowArm(row) === 'question' ? askQuestionsFromPending(row) !== null : true;
 }
@@ -137,6 +156,11 @@ export function countOwnedPendingRows(listed, deps) {
         if (typeof row !== 'object' || row === null) {
             throw new Error('approvals.list answered with a pending row that is not an object — the owned pending count is unknown');
         }
+        const family = approvalQueueRowFamilyOf(row);
+        if (family === 'unreadable')
+            throw new Error('approvals.list answered with a pending row whose family (`kind`) cannot be read — the owned pending count is unknown');
+        if (family !== 'checkpoint')
+            continue;
         if (pendingRowIsOwnedAndDecidable(row, deps))
             n++;
     }

package/dist/hitl/automaticAnswerVerdict.js

@@ -125,6 +125,17 @@ function evidenceUnreadable(card) {
     const nested = evidenceSlotOf(risk.value, 'requiresRealApproval');
     return nested.kind !== 'data' || typeof nested.value !== 'boolean';
 }
+function registryUnreadable(card) {
+    const slot = evidenceSlotOf(card, 'unreadableEvidence');
+    if (slot.kind === 'absent' || (slot.kind === 'data' && slot.value === undefined))
+        return false;
+    if (slot.kind === 'unreadable')
+        return true;
+    const list = slot.value;
+    if (!Array.isArray(list) || list.some((k) => typeof k !== 'string'))
+        return true;
+    return list.some((k) => k !== 'rememberRefused' && k !== 'ruleOffers');
+}
 function readHostAskRuleMatched(facts) {
     if (typeof facts !== 'object' || facts === null)
         return undefined;
@@ -137,17 +148,9 @@ export function automaticAnswerVerdict(card, lane, facts) {
     try {
         if (typeof card !== 'object' || card === null)
             return UNKNOWN.card_unreadable;
+        const unreadableAtEntry = registryUnreadable(card) || evidenceUnreadable(card) || (retiredAllowRuleShadowKeyPresent(card, 'frame') && !approvalAllowRuleShadowed(card));
         if (card.cardPayloadUnreadable === true)
             return UNKNOWN.card_unreadable;
-        const unreadable = card.unreadableEvidence;
-        if (unreadable !== undefined) {
-            if (!Array.isArray(unreadable) || unreadable.some((k) => typeof k !== 'string'))
-                return UNKNOWN.card_unreadable;
-            if (unreadable.some((k) => k !== 'rememberRefused' && k !== 'ruleOffers'))
-                return UNKNOWN.card_unreadable;
-        }
-        if (!approvalAllowRuleShadowed(card) && retiredAllowRuleShadowKeyPresent(card, 'frame'))
-            return UNKNOWN.card_unreadable;
         const face = lane === 'mode_posture' ? askFaceOfCard(card) : undefined;
         const origin = readAskOrigin(evidenceView(card, 'origin'));
         if (origin !== undefined && Object.hasOwn(ORIGIN_IMPLIES_CLASS, origin)) {
@@ -175,7 +178,7 @@ export function automaticAnswerVerdict(card, lane, facts) {
                     return mustAsk('allow_rule_shadow');
             }
         }
-        if (evidenceUnreadable(card))
+        if (unreadableAtEntry)
             return UNKNOWN.card_unreadable;
         const pair = readAskClassPairState(card);
         if (pair.state === 'malformed')

package/dist/hitl/crashConverged.d.ts

@@ -4,8 +4,12 @@ export interface CrashConvergedRowReading extends Readonly<CrashConvergedRow> {
     readonly needsHumanReason?: 'approved_then_interrupted' | 'pending_unsafe' | 'unstable_row' | 'contradictory';
 }
 export declare const isCrashConvergedCause: (v: unknown) => v is CrashConvergedRowReading["cause"];
+export interface ApprovalQueueKindedRow {
+    readonly kind: string;
+}
+export type ApprovalQueueRow = PendingCheckpoint | ApprovalQueueKindedRow;
 export interface ApprovalsListEnvelope {
-    pending: PendingCheckpoint[];
+    pending: ApprovalQueueRow[];
     livePending?: unknown[];
     crashConverged?: CrashConvergedRowReading[];
 }

package/dist/hitl/decisionConflict.js

@@ -1,8 +1,9 @@
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { ownDataField } from '../ownKey.js';
+import { SDK_DECIDE_BINDING_KEYS } from '../generated/sdkFactTables.js';
 import { isSlotCarrier, PROTOCOL_ERROR_NAME, protocolErrorNameReading, readRefusalSlots, readThrownExtraSnapshot } from '../wireFailureShape.js';
-const BINDING_SEAT_FIELDS = new Set(['boundCallId', 'boundInputHash']);
+const BINDING_SEAT_FIELDS = new Set(SDK_DECIDE_BINDING_KEYS);
 const ANSWER_FIELD = 'answer';
 const REFUSAL_WORD_KEYS = Object.freeze(['field', 'reason']);
 const GRANT_DIGEST_FIELD = 'boundGrantDigest';

package/dist/hitl/decisionRefusal.js

@@ -146,7 +146,7 @@ export function readDecisionRefusalAsk(failure, answer, read) {
     if (name === 'HitlSafetyError')
         return facts('not_settled');
     const code = typeof errorCode === 'string' && errorCode.length > 0 ? errorCode : undefined;
-    if (code === RESUME_PREFLIGHT_REJECTED && (preflightSettledBitsPresent(carrier) || retriable !== true))
+    if (code === RESUME_PREFLIGHT_REJECTED && preflightSettledBitsPresent(carrier))
         return facts('not_settled', true);
     if (isCodeClassifiedGateFailure(code, retriable))
         return facts('not_settled');

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';
@@ -63,6 +65,7 @@ interface HitlDecisionOutcomeBase {
     readonly fallback?: 'approval';
     readonly noteDropped?: true;
     readonly rememberDropped?: true;
+    readonly allowSessionCarried?: true;
     readonly attributionDropped?: true;
     readonly attributionRenamed?: true;
     readonly pending?: LiveAskPendingReading;