@sema-agent/client-core 0.106.0 → 0.108.0

package/dist/generated/settingsSchemaMcpRequestEntry.d.ts

@@ -1 +1 @@
-export declare const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE: (MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"], startsWithHttpScheme: (raw: string) => boolean, echoCallerText: (text: string) => string, UNINSPECTABLE: "an object that could not be inspected (a proxy trap threw)", captureStringArray: (v: unknown, classification: "strict" | "wide") => string[] | undefined, dataDescriptor: (value: unknown) => PropertyDescriptor, inspect: (read: () => unknown) => object, ownFieldsOf: (record: object, keys: readonly string[]) => object, ownValueOf: (record: object, key: string) => object, readKey: (record: object, key: PropertyKey) => object, isJsonArray: (v: unknown) => v is unknown[], jsonShapeOf: (v: unknown) => "plain" | "non_plain_object" | "array" | "null" | "primitive" | "uninspectable", isReservedMcpServerName: (name: string) => boolean, RESERVED_MCP_SERVER_NAME_REASON: "the \"remote-\" prefix is reserved for the remote MCP servers a device executor offers") => any;
+export declare const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE: (MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"], startsWithHttpScheme: (raw: string) => boolean, echoCallerText: (text: string) => string, UNINSPECTABLE: "an object that could not be inspected (a proxy trap threw)", captureStringArray: (v: unknown, classification: "strict" | "wide") => string[] | undefined, dataDescriptor: (value: unknown) => PropertyDescriptor, inspect: (read: () => unknown) => object, ownFieldsOf: (record: object, keys: readonly string[]) => object, ownValueOf: (record: object, key: string) => object, readKey: (record: object, key: PropertyKey) => object, isJsonArray: (v: unknown) => v is unknown[], jsonShapeOf: (v: unknown) => "plain" | "non_plain_object" | "array" | "null" | "primitive" | "uninspectable", isReservedMcpServerName: (name: string) => boolean, RESERVED_MCP_SERVER_NAME_REASON: "the \"remote-\" prefix is reserved for the remote MCP servers a device executor offers", TOOL_WIRE_NAME_MAX_CHARS: 128, hasEdgeWhitespace: (v: string) => boolean, isUsableWireName: (v: unknown) => v is string, isReservedMemberName: (name: string) => boolean) => any;

package/dist/generated/settingsSchemaMcpRequestEntry.js

@@ -1,4 +1,4 @@
-export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWithHttpScheme, echoCallerText, UNINSPECTABLE, captureStringArray, dataDescriptor, inspect, ownFieldsOf, ownValueOf, readKey, isJsonArray, jsonShapeOf, isReservedMcpServerName, RESERVED_MCP_SERVER_NAME_REASON) => {
+export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWithHttpScheme, echoCallerText, UNINSPECTABLE, captureStringArray, dataDescriptor, inspect, ownFieldsOf, ownValueOf, readKey, isJsonArray, jsonShapeOf, isReservedMcpServerName, RESERVED_MCP_SERVER_NAME_REASON, TOOL_WIRE_NAME_MAX_CHARS, hasEdgeWhitespace, isUsableWireName, isReservedMemberName) => {
     function describeKindWord(v) {
         const shape = jsonShapeOf(v);
         switch (shape) {
@@ -46,11 +46,6 @@ export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWi
     function quotedCallerText(text) {
         return `"${echoCallerText(text)}"`;
     }
-    const TOOL_WIRE_NAME_MAX_CHARS = 128;
-    const hasEdgeWhitespace = (v) => v.trim() !== v;
-    function isUsableWireName(v) {
-        return typeof v === "string" && v.length > 0 && v.length <= TOOL_WIRE_NAME_MAX_CHARS && !hasEdgeWhitespace(v);
-    }
     function describeBadWireName(v) {
         if (typeof v !== "string")
             return describeKindWord(v);
@@ -202,8 +197,7 @@ export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWi
         }
         return { ok: true, value: { kind: "other", value: kind.value } };
     }
-    const PLAIN_STRING_RECORD_RESERVED_MEMBER = "__proto__";
-    const RESERVED_MEMBER_FAULT = `no member of a declaration may be named "${PLAIN_STRING_RECORD_RESERVED_MEMBER}"`;
+    const reservedMemberFault = (name) => `no member of a declaration may be named "${name}"`;
     function notPlainDetail(shape, v) {
         switch (shape) {
             case "null":
@@ -233,28 +227,25 @@ export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWi
             return { ok: false, fault: "not_plain_record", detail: `got ${namesRead.sentence}` };
         const names = namesRead.value;
         const members = Object.create(null);
-        let reservedMember = false;
+        const reservedMembers = names.filter(isReservedMemberName);
         for (const name of names) {
             const read = readKey(v, name);
             const unreadable = read.presence === "unreadable";
             const value = read.presence === "own" ? read.value : undefined;
             if (unreadable || typeof value !== "string") {
                 const valueFault = unreadable ? "could not be read (its getter threw)" : `must be a string — got ${describeValueShape(value)}`;
-                const reserved = name === PLAIN_STRING_RECORD_RESERVED_MEMBER;
-                const fault = reserved ? "member_name_reserved" : "member_not_string";
+                const fault = isReservedMemberName(name) ? "member_name_reserved" : "member_not_string";
                 return {
                     ok: false,
                     fault,
                     member: echoCallerText(name),
-                    detail: `its member "${echoCallerText(name)}" ${reserved ? `is not allowed (${RESERVED_MEMBER_FAULT}) and its value ${valueFault}` : valueFault}`,
+                    detail: `its member "${echoCallerText(name)}" ${isReservedMemberName(name) ? `is not allowed (${reservedMemberFault(name)}) and its value ${valueFault}` : valueFault}`,
                 };
             }
-            if (name === PLAIN_STRING_RECORD_RESERVED_MEMBER)
-                reservedMember = true;
-            else
+            if (!isReservedMemberName(name))
                 Object.defineProperty(members, name, dataDescriptor(value));
         }
-        return { ok: true, record: { ...members }, reservedMember };
+        return { ok: true, record: { ...members }, reservedMembers };
     }
     const issuesOf = (...candidates) => candidates.filter((c) => c !== undefined);
     function readTransportRecord(path, raw) {
@@ -269,8 +260,8 @@ export const SETTINGS_MCP_REQUEST_ENTRY_CLOSURE = (MCP_CONTENT_ORIGINS, startsWi
         }
         return {
             record: read.record,
-            issues: read.reservedMember ? [{ path: `${path}.${PLAIN_STRING_RECORD_RESERVED_MEMBER}`, reason: RESERVED_MEMBER_FAULT, member: PLAIN_STRING_RECORD_RESERVED_MEMBER, fault: "member_name_reserved" }] : [],
+            issues: read.reservedMembers.map((name) => ({ path: `${path}.${name}`, reason: reservedMemberFault(name), member: name, fault: "member_name_reserved" })),
         };
     }
-    return { readRequestMcpTransport, readMcpIdentityHeaders, isUsableWireName, describeBadWireName, isUsableMcpServerName, describeBadMcpServerName, isContentOriginWord, describeBadContentOrigin, TOOL_WIRE_NAME_MAX_CHARS };
+    return { readRequestMcpTransport, readMcpIdentityHeaders, describeBadWireName, isUsableMcpServerName, describeBadMcpServerName, isContentOriginWord, describeBadContentOrigin };
 };

package/dist/generated/settingsSchemaReservedMemberName.d.ts

@@ -0,0 +1 @@
+export declare const SETTINGS_RESERVED_MEMBER_NAME_CLOSURE: () => any;

package/dist/generated/settingsSchemaReservedMemberName.js

@@ -0,0 +1,7 @@
+export const SETTINGS_RESERVED_MEMBER_NAME_CLOSURE = () => {
+    const RESERVED_MEMBER_NAMES = ["__proto__", "constructor", "prototype"];
+    function isReservedMemberName(name) {
+        return RESERVED_MEMBER_NAMES.includes(name);
+    }
+    return { isReservedMemberName };
+};

package/dist/generated/settingsSchemaTables.d.ts

@@ -13,3 +13,5 @@ export declare const SETTINGS_UI_LANGUAGE_VALUES: readonly ["en", "zh"];
 export declare const SETTINGS_MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"];
 export declare const SETTINGS_MIN_TRUST_WORDS: readonly ["local", "session", "project", "global", "managed", "task"];
 export declare const SETTINGS_WORKSPACE_TRUST_STATES: readonly ["accepted", "declined", "no_trust_step"];
+export declare const SETTINGS_MODEL_PLANE_REFUSAL_CODES: readonly ["config.default_model_missing", "config.model_refused_name_minted", "config.model_route_endpoint_missing", "config.gateway_fallback_without_primary", "config.catalog_replaces_env_models"];
+export declare const SETTINGS_NO_EXECUTION_TARGET_LANES: readonly ["none"];

package/dist/generated/settingsSchemaTables.js

@@ -63,3 +63,13 @@ export const SETTINGS_WORKSPACE_TRUST_STATES = Object.freeze([
     "declined",
     "no_trust_step",
 ]);
+export const SETTINGS_MODEL_PLANE_REFUSAL_CODES = Object.freeze([
+    "config.default_model_missing",
+    "config.model_refused_name_minted",
+    "config.model_route_endpoint_missing",
+    "config.gateway_fallback_without_primary",
+    "config.catalog_replaces_env_models",
+]);
+export const SETTINGS_NO_EXECUTION_TARGET_LANES = Object.freeze([
+    "none",
+]);

package/dist/generated/settingsSchemaWireName.d.ts

@@ -0,0 +1 @@
+export declare const SETTINGS_WIRE_NAME_CLOSURE: () => any;

package/dist/generated/settingsSchemaWireName.js

@@ -0,0 +1,8 @@
+export const SETTINGS_WIRE_NAME_CLOSURE = () => {
+    const TOOL_WIRE_NAME_MAX_CHARS = 128;
+    const hasEdgeWhitespace = (v) => v.trim() !== v;
+    function isUsableWireName(v) {
+        return typeof v === "string" && v.length > 0 && v.length <= TOOL_WIRE_NAME_MAX_CHARS && !hasEdgeWhitespace(v);
+    }
+    return { isUsableWireName, TOOL_WIRE_NAME_MAX_CHARS, hasEdgeWhitespace };
+};

package/dist/headlessReconnectWire.js

@@ -53,7 +53,7 @@ export async function* withHeadlessR1Reconnect(live, deps) {
     let attempts = 0;
     let lastSeenSeq;
     const probe = deps.probeAlive ?? probeEngineAlive;
-    let isRecoverableTear;
+    let tearShape;
     const drains = createStreamDrainingLegs();
     let drainReopenAfterMs;
     let lastBreak;
@@ -62,6 +62,11 @@ export async function* withHeadlessR1Reconnect(live, deps) {
             registerRunNotFollowed(originalTearErr, fact);
         throw originalTearErr;
     };
+    const unboundHandle = (cause) => {
+        if (tearShape === 'transport')
+            throw originalTearErr;
+        return giveUp(mintRunNotFollowed(cause));
+    };
     const terminalFromRunRow = async (taskId) => {
         const row = await deps.getRun(taskId).catch(() => null);
         const terminal = terminalEventFromRunRow(row);
@@ -72,21 +77,21 @@ export async function* withHeadlessR1Reconnect(live, deps) {
     for (;;) {
         if (deps.signal?.aborted)
             throw originalTearErr;
-        if (isRecoverableTear === undefined)
-            isRecoverableTear = isSseIdleError(originalTearErr);
-        if (!isRecoverableTear)
+        if (tearShape === undefined)
+            tearShape = isSseIdleError(originalTearErr) ? 'idle' : guardedTransport(originalTearErr) ? 'transport' : 'other';
+        if (tearShape === 'other')
             throw originalTearErr;
         let handle;
         try {
             handle = deps.getTaskId();
         }
         catch {
-            return giveUp(mintRunNotFollowed('bad_input'));
+            return unboundHandle('bad_input');
         }
         if (handle === null || handle === undefined)
-            return giveUp(mintRunNotFollowed('no_run_id'));
+            return unboundHandle('no_run_id');
         if (typeof handle !== 'string' || handle === '')
-            return giveUp(mintRunNotFollowed('bad_input'));
+            return unboundHandle('bad_input');
         const taskId = handle;
         if (drainReopenAfterMs !== undefined) {
             const waitMs = drainReopenAfterMs;

package/dist/hitl/approvalAskers.d.ts

@@ -0,0 +1,13 @@
+export interface ApprovalAskReasonByHook {
+    readonly by: 'hook';
+    readonly cause: string;
+    readonly registration?: string;
+    readonly words?: string;
+}
+export interface ApprovalAskReasonByPolicy {
+    readonly by: string;
+    readonly words: string;
+}
+export type ApprovalAskReason = ApprovalAskReasonByHook | ApprovalAskReasonByPolicy;
+export declare function approvalAskReasonsOf(carrier: object | null | undefined): readonly ApprovalAskReason[] | undefined;
+export declare function approvalAgentIdOf(carrier: object | null | undefined): string | undefined;

package/dist/hitl/approvalAskers.js

@@ -0,0 +1,79 @@
+import { appendOwnElement } from '../ownKey.js';
+import { slotReadOf } from '../wireFailureShape.js';
+function ownNonEmptyText(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' && typeof r.value === 'string' && r.value !== '' ? r.value : undefined;
+}
+function optionalText(o, key) {
+    const r = slotReadOf(o, key);
+    if (r.presence === 'absent')
+        return { state: 'absent' };
+    if (r.presence === 'present' && typeof r.value === 'string')
+        return { state: 'text', value: r.value };
+    return { state: 'bad' };
+}
+function askReasonOf(item) {
+    if (typeof item !== 'object' || item === null)
+        return undefined;
+    const by = ownNonEmptyText(item, 'by');
+    if (by === undefined)
+        return undefined;
+    const words = optionalText(item, 'words');
+    if (words.state === 'bad')
+        return undefined;
+    if (by === 'hook') {
+        const cause = ownNonEmptyText(item, 'cause');
+        if (cause === undefined)
+            return undefined;
+        const registration = optionalText(item, 'registration');
+        if (registration.state === 'bad')
+            return undefined;
+        return Object.freeze({
+            by: 'hook',
+            cause,
+            ...(registration.state === 'text' ? { registration: registration.value } : {}),
+            ...(words.state === 'text' ? { words: words.value } : {}),
+        });
+    }
+    if (words.state !== 'text')
+        return undefined;
+    return Object.freeze({ by, words: words.value });
+}
+export function approvalAskReasonsOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null)
+            return undefined;
+        const slot = slotReadOf(carrier, 'askReasons');
+        if (slot.presence !== 'present')
+            return undefined;
+        const raw = slot.value;
+        if (typeof raw !== 'object' || raw === null || !Array.isArray(raw))
+            return undefined;
+        const len = slotReadOf(raw, '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 el = slotReadOf(raw, String(i));
+            if (el.presence !== 'present')
+                return undefined;
+            const reason = askReasonOf(el.value);
+            if (reason !== undefined)
+                appendOwnElement(out, reason);
+        }
+        return out.length === 0 ? undefined : Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalAgentIdOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null)
+            return undefined;
+        return ownNonEmptyText(carrier, 'agentId');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/approvalResolution.d.ts

@@ -1,18 +1,21 @@
 import type { DecideReceiptView } from '../decideReceipt.js';
 import { type HitlSafetyCode } from './hitlBridge.js';
 import type { AskAnsweredOutput } from './gateLedger.js';
+import type { PolicyDenyCause } from './policyDenyCause.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];
 export interface ApprovalDenyFacts {
     readonly settledBy?: ApprovalDenySettledBy;
     readonly reason?: string;
+    readonly policyCause?: PolicyDenyCause;
     readonly attributionKey?: 'dropped' | 'renamed';
 }
 interface ApprovalResolutionBase {
@@ -32,6 +35,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 {
@@ -49,6 +55,7 @@ export declare function approvalUnsettledCause(r: ApprovalResolution): ApprovalU
 export declare const APPROVAL_NOTE_RETRACTED_DETAIL = "the card was retracted (this host no longer has a decision port for it)";
 export declare const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = "edits are not accepted on this card";
 export declare function approvalResolutionDetail(r: ApprovalResolution): string | undefined;
+export declare function approvalResolutionStatusTag(r: ApprovalResolution): string;
 export declare function unsettledCauseOfReading(reading: DecisionRefusalReading): 'engine_refused' | 'engine_error' | 'no_answer';
 export interface DecisionFailureMint {
     readonly lane: ApprovalResolutionLane;

package/dist/hitl/approvalResolution.js

@@ -1,9 +1,10 @@
 import { DecideTransportRetryExhaustedError, refusalCarrierOf, safetyStopHeadOf, safetyStopNamed } from './hitlBridge.js';
-import { mintDecisionRefusalReading } from './decisionRefusal.js';
+import { decisionStatusTag, mintDecisionRefusalReading } from './decisionRefusal.js';
 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, unboundWayOutContent } from '../checkpointRowVerdict.js';
 export const APPROVAL_RESOLUTION_LANES = Object.freeze(['respond', 'decide', 'ask']);
 export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'retracted',
@@ -14,6 +15,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 +51,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 +80,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}) · ${unboundWayOutContent('unknown')}` : `${sentence} (${code})`;
     }
     if (kind !== 'unsettled')
         return undefined;
@@ -93,6 +109,25 @@ export function approvalResolutionDetail(r) {
     const parts = [ownStr(refusal, 'errorCode'), ownStr(r, 'detail') ?? ownStr(refusal, 'message')].filter((x) => x !== undefined);
     return parts.length > 0 ? parts.join(' · ') : undefined;
 }
+export function approvalResolutionStatusTag(r) {
+    try {
+        if (typeof r !== 'object' || r === null)
+            return '';
+        const kd = Object.getOwnPropertyDescriptor(r, 'kind');
+        if (kd === undefined || !Object.hasOwn(kd, 'value') || kd.value !== 'unsettled')
+            return '';
+        const rd = Object.getOwnPropertyDescriptor(r, 'refusal');
+        const refusal = rd !== undefined && Object.hasOwn(rd, 'value') ? rd.value : undefined;
+        if (typeof refusal !== 'object' || refusal === null)
+            return '';
+        const sd = Object.getOwnPropertyDescriptor(refusal, 'status');
+        const status = sd !== undefined && Object.hasOwn(sd, 'value') ? sd.value : undefined;
+        return typeof status === 'number' && Number.isInteger(status) && status >= 400 && status <= 599 ? decisionStatusTag(status) : '';
+    }
+    catch {
+        return '';
+    }
+}
 export function unsettledCauseOfReading(reading) {
     const standing = ownReadingSlot(reading, 'standing');
     if (standing === 'ambiguous')

package/dist/hitl/approvalsFeed.js

@@ -1,8 +1,10 @@
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.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;
@@ -49,7 +51,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('');
@@ -175,12 +177,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         const at = Date.now();
         blind = { why, at };
         stats.unknowns++;
-        try {
-            onSnapshot({ kind: 'unknown', why, at, mode: via });
-        }
-        catch (e) {
-            hostLog('debug', `approvalsFeed: subscriber threw on the unknown arm (swallowed): ${String(e)}`);
-        }
+        invokeHostCallbackIsolated('approvalsFeed: subscriber (unknown arm)', () => onSnapshot({ kind: 'unknown', why, at, mode: via }));
     }
     async function take(via, leg) {
         if (stopped)
@@ -292,12 +289,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         };
         last = snap;
         stats.snapshots++;
-        try {
-            onSnapshot(snap);
-        }
-        catch (e) {
-            hostLog('debug', `approvalsFeed: subscriber threw (swallowed): ${String(e)}`);
-        }
+        invokeHostCallbackIsolated('approvalsFeed: subscriber', () => onSnapshot(snap));
     }
     function schedulePoll() {
         if (stopped || ac.signal.aborted)

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,15 @@ 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,
+            rowTaskId: askParkRowTaskIdOf(taskId, pending),
+        };
+    }
     if (foreignKind !== null) {
         return {
             kind: 'unborn',
@@ -40,8 +51,11 @@ export function classifyAskParkRows(queueRows, taskId, deps) {
 function askParkRowGateKind(row) {
     return typeof row.gateKind === 'string' && row.gateKind.length > 0 ? row.gateKind : null;
 }
+function askParkRowTaskIdOf(taskId, row) {
+    return typeof row.taskId === 'string' && row.taskId.length > 0 ? row.taskId : taskId;
+}
 export function askParkRowIdentity(taskId, row) {
-    const rowTaskId = typeof row.taskId === 'string' && row.taskId.length > 0 ? row.taskId : taskId;
+    const rowTaskId = askParkRowTaskIdOf(taskId, row);
     const gatedCallId = row.toolCallId ?? row.boundCallId ?? undefined;
     return { rowTaskId, gatedCallId, armedKey: approvalCallKey(gatedCallId, rowTaskId) };
 }
@@ -129,6 +143,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/decisionRefusal.d.ts

@@ -78,5 +78,6 @@ export interface UndeliverableDecisionFacts {
     readonly end: UndeliverableDecisionEnd;
     readonly runId?: string;
 }
+export declare function decisionStatusTag(status: number, errorCode?: string): string;
 export declare function undeliverableDecisionContent(facts: UndeliverableDecisionFacts): string;
 export declare function decideRowUnrevivableNotice(lang?: UiLanguage | (string & {})): string;

package/dist/hitl/decisionRefusal.js

@@ -314,9 +314,12 @@ export function decisionRefusalClosesOut(refusal, pending) {
         return false;
     return standing === 'ambiguous' || standing === 'refused-pending';
 }
+export function decisionStatusTag(status, errorCode) {
+    const code = typeof errorCode === 'string' && isDisplayableWireCode(errorCode) ? ` ${errorCode}` : '';
+    return `(HTTP ${String(status)}${code})`;
+}
 export function undeliverableDecisionContent(facts) {
-    const code = typeof facts.errorCode === 'string' && isDisplayableWireCode(facts.errorCode) ? ` ${facts.errorCode}` : '';
-    const head = `The engine refused the approval decision this client sent (HTTP ${String(facts.status)}${code}), so the call it asked about could not be answered from here and did not run`;
+    const head = `The engine refused the approval decision this client sent ${decisionStatusTag(facts.status, facts.errorCode)}, so the call it asked about could not be answered from here and did not run`;
     const runId = typeof facts.runId === 'string' && isDisplayableWireCode(facts.runId) ? ` ${facts.runId}` : '';
     switch (facts.end) {
         case 'run-stopped':

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

@@ -1,5 +1,6 @@
 import { settleWithinDeadline } from '../abortableSleep.js';
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { askGoneFromError } from '../decideReceipt.js';
 import { appendOwnElement, guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
@@ -10,7 +11,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 +196,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 };
@@ -343,12 +344,7 @@ function holdFits(handle, req) {
     }
 }
 function callHold(call) {
-    try {
-        call();
-    }
-    catch (e) {
-        hostLog('debug', `decisionSend.callHold: ${String(e).slice(0, 120)}`);
-    }
+    invokeHostCallbackIsolated('decisionSend: hold verb', call);
 }
 function hostField(holder, key) {
     if (typeof holder !== 'object' || holder === null)
@@ -386,6 +382,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 +403,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 +525,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/frameRouter.d.ts

@@ -1,8 +1,8 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import type { DecideOperationObserver, HitlClientLike } from './hitlBridge.js';
 import { type RespondToolApprovalFn, type ToolApprovalFrame, type ToolApprovalFrameLaneOpts } from './toolApprovalWire.js';
-import type { ApprovalResolution } from './approvalResolution.js';
-import type { GateLedger } from './gateLedger.js';
+import type { ApprovalDenyFacts, ApprovalResolution } from './approvalResolution.js';
+import type { GateLedger, GateDenyAttribution } from './gateLedger.js';
 import type { NoAllowCause } from './noAllowCause.js';
 import { type ReplayedApprovalDisposition } from './replayedApproval.js';
 import type { ReattachDrainingEvent } from '../runReattachPolicy.js';
@@ -17,6 +17,7 @@ export interface PolicyDenyReasonFacts {
     readonly budgetSetting?: string;
 }
 export declare function policyDenyReason(facts: PolicyDenyReasonFacts): string;
+export declare function denyAttributionOf(deny: ApprovalDenyFacts | undefined): GateDenyAttribution;
 export declare const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
 export declare const ENGINE_ABORT_TOOL_RESULT = "Operation aborted";
 export interface ParkReattachNotice {