@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/hitl/approvalAskers.js

@@ -67,6 +67,36 @@ export function approvalAskReasonsOf(carrier) {
         return undefined;
     }
 }
+export function requestedByViewOf(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const kind = slotReadOf(v, 'kind');
+        if (kind.presence !== 'present' || kind.value !== 'extension')
+            return undefined;
+        const name = ownNonEmptyText(v, 'name');
+        if (name === undefined)
+            return undefined;
+        return Object.freeze({ kind: 'extension', name });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function approvalRequestedByOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null)
+            return undefined;
+        const slot = slotReadOf(carrier, 'requestedBy');
+        if (slot.presence !== 'present')
+            return undefined;
+        const v = slot.value;
+        return typeof v === 'object' && v !== null ? requestedByViewOf(v) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function approvalAgentIdOf(carrier) {
     try {
         if (typeof carrier !== 'object' || carrier === null)

package/dist/hitl/approvalCardReasons.js

@@ -4,7 +4,7 @@ import { approvalMandateDetail, askOriginNoteOf } from '../gateVocabulary.js';
 import { readAskOrigin, readOwnDataValue, guardedRead } from '../ownKey.js';
 import { elideMiddleForDisplay } from '../noticePresentation.js';
 import { allowRuleShadowSentence } from './allowRuleShadow.js';
-import { approvalUnreadableWhyWordOf } from './approvalRequestFrameReading.js';
+import { cardPayloadReadingOf } from './approvalRequestFrameReading.js';
 import { mandatedApprovalDetailOf } from './automaticAnswerVerdict.js';
 import { approvalBoundGrantsDetail, approvalIsMandated, approvalPriorCardsDetail, askProbeReasonDetail, classifierNoRulingDetail, readApprovalBoundGrants, readApprovalClassifierNoRuling, readApprovalMandate, readDenialLimitFallback, } from './toolApprovalWire.js';
 export const APPROVAL_CARD_REASON_SOURCES = Object.freeze([
@@ -31,7 +31,7 @@ function engineMessageLine(engineMessage) {
     return settled.length <= MESSAGE_DISPLAY_MAX ? settled : displayUntrusted(engineMessage, { max: MESSAGE_DISPLAY_MAX });
 }
 function payloadUnreadableDetail(why, lang) {
-    switch (typeof why === 'string' ? approvalUnreadableWhyWordOf(why) : undefined) {
+    switch (why) {
         case 'version_unknown':
             return renderMessage(msg('approval.card.payloadUnreadable.versionUnknown'), lang);
         case 'kind_unknown':
@@ -82,7 +82,10 @@ export function approvalCardReasons(card, opts, lang) {
     catch {
         denialLimitReadable = false;
     }
-    add('payload_unreadable', () => (ownData(card, 'cardPayloadUnreadable') === true ? payloadUnreadableDetail(ownData(card, 'cardPayloadUnreadableWhy'), lang) : undefined));
+    add('payload_unreadable', () => {
+        const reading = cardPayloadReadingOf(card);
+        return reading.payloadUnreadable ? payloadUnreadableDetail(reading.why, lang) : undefined;
+    });
     add('prior_cards', () => approvalPriorCardsDetail(card, lang));
     add('message', () => {
         const engineMessage = ownData(card, 'message');

package/dist/hitl/approvalDelivery.d.ts

@@ -1,6 +1,7 @@
 import { type AnswerCapture, type TopCauseReading, type TopLocalCodeReading, type UnansweredCapture } from '../engineWireFor.js';
 import { type AttributionLadderState, type AttributionLadderStep } from './attributionLadder.js';
 import { type RefusalCarrier, type SafetyStopHead } from './hitlBridge.js';
+export declare const RETRY_BUDGET_MS = 8000;
 export declare const PARKING_WAIT_CAP_MS = 5000;
 export interface DeliveryTiming {
     readonly delays?: readonly number[];

package/dist/hitl/approvalDelivery.js

@@ -5,7 +5,7 @@ import { isSlotCarrier, readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFa
 import { deliverWithAttributionLadder, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
 import { GATE_FAILURE_CODES, refusalCarrierOf, safetyStopHeadOf } from './hitlBridge.js';
 const RETRY_DELAYS_MS = Object.freeze([500, 1_000, 2_000]);
-const RETRY_BUDGET_MS = 8_000;
+export const RETRY_BUDGET_MS = 8_000;
 export const PARKING_WAIT_CAP_MS = 5_000;
 let timingOverride;
 export function setDeliveryTimingForTests(t) {

package/dist/hitl/approvalRequestFrameReading.d.ts

@@ -11,4 +11,11 @@ export type ApprovalRequestFrameReading = {
 export declare function approvalRequestFrameReadingThrowing(frame: object | null | undefined): ApprovalRequestFrameReading;
 export declare function approvalRequestFrameReadingOf(frame: object | null | undefined): ApprovalRequestFrameReading;
 export declare function approvalUnreadableWhyWordOf(v: string): ApprovalRequestFrameUnreadableWhy | undefined;
+export type CardPayloadReading = {
+    readonly payloadUnreadable: false;
+} | {
+    readonly payloadUnreadable: true;
+    readonly why?: ApprovalRequestFrameUnreadableWhy;
+};
+export declare function cardPayloadReadingOf(card: object | null | undefined): CardPayloadReading;
 export declare function approvalFrameUnreadableWhyOf(reading: ApprovalRequestFrameReading | null | undefined): ApprovalRequestFrameUnreadableWhy | undefined;

package/dist/hitl/approvalRequestFrameReading.js

@@ -1,5 +1,6 @@
 import { isApprovalRequestFrameV1 } from '@sema-agent/sdk';
 import { displayUntrusted } from '../displayUntrusted.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 export const APPROVAL_REQUEST_FRAME_UNREADABLE_WHYS = Object.freeze(['version_unknown', 'kind_unknown', 'unreadable_fields']);
 const KNOWN_FRAME_TYPE = 'approval_request';
 const KNOWN_SCHEMA_VERSION = 1;
@@ -60,6 +61,16 @@ export function approvalRequestFrameReadingOf(frame) {
 export function approvalUnreadableWhyWordOf(v) {
     return APPROVAL_REQUEST_FRAME_UNREADABLE_WHYS.find((w) => w === v);
 }
+export function cardPayloadReadingOf(card) {
+    if (typeof card !== 'object' || card === null)
+        return Object.freeze({ payloadUnreadable: false });
+    const flag = guardedRead(() => readOwnDataValue(card, 'cardPayloadUnreadable'));
+    if (flag !== true)
+        return Object.freeze({ payloadUnreadable: false });
+    const word = guardedRead(() => readOwnDataValue(card, 'cardPayloadUnreadableWhy'));
+    const why = typeof word === 'string' ? approvalUnreadableWhyWordOf(word) : undefined;
+    return why === undefined ? Object.freeze({ payloadUnreadable: true }) : Object.freeze({ payloadUnreadable: true, why });
+}
 export function approvalFrameUnreadableWhyOf(reading) {
     try {
         if (typeof reading !== 'object' || reading === null)

package/dist/hitl/approvalResolution.d.ts

@@ -8,7 +8,7 @@ import { type DeliveredReading, type LadderSafetyStop } from './attributionLadde
 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", "row_unresumable"];
+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", "withdrawn"];
 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];
@@ -18,6 +18,11 @@ export interface ApprovalDenyFacts {
     readonly policyCause?: PolicyDenyCause;
     readonly attributionKey?: 'dropped' | 'renamed';
 }
+export interface ToolPermissionSettledElsewhere {
+    readonly firstDecision: 'allow' | 'deny';
+    readonly contrary: boolean;
+}
+export declare function toolPermissionSettledElsewhereOf(first: 'allow' | 'deny', sent: ToolApprovalRespondDecision | 'approve'): ToolPermissionSettledElsewhere;
 interface ApprovalResolutionBase {
     readonly lane: ApprovalResolutionLane;
     readonly gatedCallId?: string;
@@ -30,6 +35,7 @@ export interface ApprovalResolutionDecided extends ApprovalResolutionBase {
     readonly receipt?: DecideReceiptView;
     readonly ack?: ToolApprovalRespondAckView;
     readonly answered?: AskAnsweredOutput;
+    readonly settledElsewhere?: ToolPermissionSettledElsewhere;
 }
 export interface ApprovalResolutionNotSent extends ApprovalResolutionBase {
     readonly kind: 'not_sent';
@@ -38,6 +44,7 @@ export interface ApprovalResolutionNotSent extends ApprovalResolutionBase {
     readonly rowVerdict?: Exclude<CheckpointRowVerdictReading, {
         readonly kind: 'ok';
     }>;
+    readonly toldBy?: 'host';
     readonly detail?: string;
 }
 export interface ApprovalResolutionUnsettled extends ApprovalResolutionBase {
@@ -53,7 +60,7 @@ export declare function isApprovalDecided(r: ApprovalResolution): r is ApprovalR
 export declare function approvalNotSentCause(r: ApprovalResolution): ApprovalNotSentCause | undefined;
 export declare function approvalUnsettledCause(r: ApprovalResolution): ApprovalUnsettledCause | undefined;
 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 const APPROVAL_NOTE_EDIT_REFUSED_DETAIL: string;
 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';

package/dist/hitl/approvalResolution.js

@@ -5,6 +5,7 @@ import { carrierReadOf, isLocalSafetyStop, localCodeReadOf, topCauseReadOf } fro
 import { directFailureReadingOf, transportReadingOf } from './approvalDelivery.js';
 import { ownReadingSlot } from '../engineWireFor.js';
 import { CHECKPOINT_ROW_BAR_SENTENCE, unboundWayOutContent } 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',
@@ -16,6 +17,7 @@ export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'card_unavailable',
     'safety_stop',
     'row_unresumable',
+    'withdrawn',
 ]);
 export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'engine_refused',
@@ -27,6 +29,9 @@ export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'orchestration',
     'unreadable',
 ]);
+export function toolPermissionSettledElsewhereOf(first, sent) {
+    return Object.freeze({ firstDecision: first, contrary: (first === 'deny') !== (sent === 'deny') });
+}
 export function isApprovalDecided(r) {
     return typeof r === 'object' && r !== null && r.kind === 'decided';
 }
@@ -41,7 +46,7 @@ export function approvalUnsettledCause(r) {
     return r.cause;
 }
 export const APPROVAL_NOTE_RETRACTED_DETAIL = 'the card was retracted (this host no longer has a decision port for it)';
-export const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = 'edits are not accepted on this card';
+export const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = renderMessage(msg('approval.editRefusal.stem'));
 const NOT_SENT_SENTENCES = Object.freeze({
     retracted: APPROVAL_NOTE_RETRACTED_DETAIL,
     edit_refused: APPROVAL_NOTE_EDIT_REFUSED_DETAIL,

package/dist/hitl/askGateWire.js

@@ -1,9 +1,10 @@
 import { createGateLedger } from './gateLedger.js';
-import { bridgeRunHandleFallbackOf, flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.js';
+import { flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.js';
 import { resolvePark, nextHopBudget, stalledTerminal, MAX_GATE_HOPS } from './parkResolver.js';
 import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
 import { abortableSleep } from '../abortableSleep.js';
 import { hostLog } from '../host.js';
+import { sourceGenerationNow } from './screenCardCarriers.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { decideAcceptedNotResolved, readDecideReceipt } from '../decideReceipt.js';
 import { APPROVAL_EXPIRED } from '../engineErrorCodes.js';
@@ -28,6 +29,7 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
         deps,
         taskId,
         ...(opts?.signal ? { signal: opts.signal } : {}),
+        streamGeneration: sourceGenerationNow(deps),
     };
     let stream = source;
     let budget;
@@ -81,17 +83,12 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             const drained = drains.legEnded('returned');
             if (drained !== undefined) {
                 const reopenAfterMs = 'reconnectAfterMs' in drained ? drained.reconnectAfterMs : undefined;
-                if (taskId.current === undefined) {
-                    const bound = bridgeRunHandleFallbackOf(deps);
-                    if (bound !== undefined && reopenAfterMs !== undefined)
-                        taskId.current = bound;
-                }
                 if (reopenAfterMs !== undefined && taskId.current !== undefined && !opts?.signal?.aborted) {
                     hostLog('debug', `liveHitlAskWire: runs.events(${taskId.current}) ended on the drain end frame — the engine is going down; reopening in ${reopenAfterMs}ms`);
                     await abortableSleep(reopenAfterMs, opts?.signal ?? new AbortController().signal);
                     if (!opts?.signal?.aborted) {
                         const seq = led.lastSeq();
-                        led.beginStreamSegment();
+                        ctx.streamGeneration = sourceGenerationNow(deps);
                         stream = deps.runsEvents(taskId.current, {
                             ...(seq !== undefined ? { lastEventId: seq } : {}),
                             ...(opts?.signal ? { signal: opts.signal } : {}),
@@ -170,7 +167,7 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             led.forgetRunScopedState();
         }
         const seq = handoff !== undefined ? undefined : led.lastSeq();
-        led.beginStreamSegment();
+        ctx.streamGeneration = sourceGenerationNow(deps);
         stream = deps.runsEvents(taskId.current, {
             ...(seq !== undefined ? { lastEventId: seq } : {}),
             ...(opts?.signal ? { signal: opts.signal } : {}),

package/dist/hitl/automaticAnswerVerdict.js

@@ -61,13 +61,13 @@ export function foldModeArbitrationRow(classes, askFace) {
         return ORDINARY_ROW;
     return Object.freeze({ bypassImmune, classifierEligible, sandboxAdmission, ruleMayClear, hookAskFloor });
 }
-const REAL_APPROVAL_CLASSES = new Set(CORE_REAL_APPROVAL_ASK_CLASSES);
+const HOOK_BLOCKING_CLASSES = new Set([...CORE_REAL_APPROVAL_ASK_CLASSES, ORIGIN_IMPLIES_CLASS.content_question]);
 function classBlocks(lane, c, face) {
     if (lane === 'mode_posture')
         return bypassImmuneOn(c, face);
     if (lane === 'standing_rule')
         return !TABLE[c].ruleMayClear;
-    return REAL_APPROVAL_CLASSES.has(c);
+    return HOOK_BLOCKING_CLASSES.has(c);
 }
 function mustAsk(road, extra) {
     return Object.freeze({ kind: 'must_ask', road, ...(extra?.askClass !== undefined ? { askClass: extra.askClass } : {}), ...(extra?.origin !== undefined ? { origin: extra.origin } : {}) });

package/dist/hitl/decisionConflict.js

@@ -1,4 +1,4 @@
-import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_UNSUPPORTED_VERSION, RESUME_OUTCOME_INVALID } from '../engineErrorCodes.js';
+import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_INVALID_OUTCOME, 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';
@@ -28,16 +28,19 @@ export function decisionConflictOf(err, captured, protocolNameRead) {
             return undefined;
         }
     }
-    const protocolName = namedProtocolOf(protocolNameRead ?? protocolErrorNameReading(err, extra));
+    const protocolName = namedProtocolOf(protocolNameRead ?? protocolErrorNameReading(err));
     if (code === CHECKPOINT_UNSUPPORTED_VERSION)
         return 'format_version';
     const bindingFamily = code === APPROVAL_BINDING_MISMATCH || (code === undefined && protocolName === PROTOCOL_ERROR_NAME.ApprovalBindingMismatchError);
-    if (!bindingFamily && code !== RESUME_OUTCOME_INVALID)
+    const rowOwnFamily = code === CHECKPOINT_INVALID_OUTCOME || (code === undefined && protocolName === PROTOCOL_ERROR_NAME.CheckpointInvalidOutcomeError);
+    if (!bindingFamily && !rowOwnFamily && code !== RESUME_OUTCOME_INVALID)
         return undefined;
     const slots = readRefusalSlots(err, REFUSAL_WORD_KEYS, extra.bag);
     const field = slots.field.word;
     if (code === RESUME_OUTCOME_INVALID)
         return field === ANSWER_FIELD ? 'answer_invalid' : field === GRANT_DIGEST_FIELD ? 'grant_changed' : undefined;
+    if (rowOwnFamily)
+        return field === undefined && !slots.field.present && slots.reason.word !== undefined ? 'row_integrity' : undefined;
     if (field === undefined) {
         if (slots.field.present)
             return undefined;

package/dist/hitl/decisionRefusal.d.ts

@@ -19,6 +19,8 @@ export interface RefusalRouteContext {
     readonly afterRetry?: true;
 }
 export declare function notPendingAfterRetry(status: number | undefined, retried: boolean): boolean;
+type RefusalRoute = NonNullable<RefusalRouteContext['route']>;
+export declare const REFUSAL_ROUTES: readonly RefusalRoute[];
 export interface RefusalDelivery {
     readonly delivery: 'refused' | 'ambiguous' | 'no_answer';
     readonly status?: number;

package/dist/hitl/decisionRefusal.js

@@ -7,7 +7,7 @@ import { isAlreadyResolvedGateReason, isCodeClassifiedGateFailure } from './park
 import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
-import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorPresent, readErrorRecord, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorPresent, readErrorString, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
 import { attributionRefusalOf, carrierReadOf } from './attributionLadder.js';
 import { CODE_UNREADABLE, ownReadingSlot } from '../engineWireFor.js';
 export const ASK_DECIDED_CODE = 'conflict.ask_decided';
@@ -29,7 +29,7 @@ export function notPendingAfterRetry(status, retried) {
     return retried && (status === 404 || status === 410);
 }
 const ROUTE_WORDS = { approval_decide: true, live_respond: true, ask_decide: true, plan_review: true, compact: true };
-const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
+export const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
 const PRIOR_REFUSAL_EVIDENCE = Object.freeze([
     Object.freeze({
         errorCode: 'corrupt',
@@ -74,12 +74,11 @@ const codeUnreadable = () => {
     throw new TypeError('status or errorCode was unreadable when this failure was first read');
 };
 function preflightSettledBitsPresent(carrier) {
-    const detail = guardedRead(() => readErrorRecord(carrier, 'detail'));
-    if (detail === undefined)
-        return false;
-    const bit = (k) => guardedRead(() => readOwnDataValue(detail, k));
-    const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
-    return nonEmpty(bit('settledBy')) || nonEmpty(bit('rowStatus'));
+    const nonEmpty = (k) => {
+        const v = guardedRead(() => readErrorString(carrier, k));
+        return typeof v === 'string' && v.length > 0;
+    };
+    return nonEmpty('settledBy') || nonEmpty('rowStatus');
 }
 const RESOLUTION_KINDS = Object.freeze(['decided', 'not_sent', 'unsettled']);
 const ASK_READINGS = Object.freeze(['settled', 'not_settled', 'unreadable']);
@@ -226,6 +225,7 @@ export function mintDecisionRefusalReading(err, context, attributionCarried, del
     const acceptableForm = errorCode === RESUME_CONSTRAINT_REJECTED && obj !== undefined ? isolated(() => readErrorPresent(obj, 'acceptableForm')) : undefined;
     const transient = inRange &&
         conflict !== 'grant_changed' &&
+        conflict !== 'row_integrity' &&
         !unrecoverable &&
         (TRANSIENT_STATUSES.has(status) || retriable || (status === 404 && obj !== undefined && isolated(() => notPendingCauseReading(obj)) === 'other_replica'));
     return Object.freeze({

package/dist/hitl/decisionRefusalCarrier.d.ts

@@ -0,0 +1,3 @@
+import { type DecisionRefusalCarrier } from '../seatContract.js';
+export declare function decisionRefusalCarrierReaderNames(): readonly string[];
+export declare function decisionRefusalCarrierOf(err: {} | null | undefined): DecisionRefusalCarrier | undefined;