@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/hitl/approvalCardReasons.js

@@ -2,7 +2,9 @@ import { displayUntrusted } from '../displayUntrusted.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { approvalMandateDetail, askOriginNoteOf } from '../gateVocabulary.js';
 import { readAskOrigin, readOwnDataValue, guardedRead } from '../ownKey.js';
+import { elideMiddleForDisplay } from '../noticePresentation.js';
 import { allowRuleShadowSentence } from './allowRuleShadow.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([
@@ -21,8 +23,24 @@ export const APPROVAL_CARD_REASON_SOURCES = Object.freeze([
 ]);
 export const APPROVAL_CARD_REASONS_DEFAULT_MAX_LINES = 4;
 const MESSAGE_DISPLAY_MAX = 300;
-function payloadUnreadableDetail(lang) {
-    return renderMessage(msg('approval.card.payloadUnreadable'), lang);
+function engineMessageLine(engineMessage) {
+    const shown = displayUntrusted(engineMessage);
+    if (shown.length <= MESSAGE_DISPLAY_MAX)
+        return shown;
+    const settled = displayUntrusted(elideMiddleForDisplay(shown, MESSAGE_DISPLAY_MAX));
+    return settled.length <= MESSAGE_DISPLAY_MAX ? settled : displayUntrusted(engineMessage, { max: MESSAGE_DISPLAY_MAX });
+}
+function payloadUnreadableDetail(why, lang) {
+    switch (why) {
+        case 'version_unknown':
+            return renderMessage(msg('approval.card.payloadUnreadable.versionUnknown'), lang);
+        case 'kind_unknown':
+            return renderMessage(msg('approval.card.payloadUnreadable.partUnknown'), lang);
+        case 'unreadable_fields':
+            return renderMessage(msg('approval.card.payloadUnreadable.fieldsMalformed'), lang);
+        default:
+            return renderMessage(msg('approval.card.payloadUnreadable'), lang);
+    }
 }
 function moreDetail(n, lang) {
     return renderMessage(n === 1 ? msg('approval.card.more.one') : msg('approval.card.more.other', { count: n }), lang);
@@ -64,7 +82,10 @@ export function approvalCardReasons(card, opts, lang) {
     catch {
         denialLimitReadable = false;
     }
-    add('payload_unreadable', () => (ownData(card, 'cardPayloadUnreadable') === true ? payloadUnreadableDetail(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');
@@ -73,7 +94,7 @@ export function approvalCardReasons(card, opts, lang) {
         const tool = ownData(card, 'toolName');
         if (typeof tool === 'string' && engineMessage.trim() === `approval required for "${tool}"`)
             return undefined;
-        return displayUntrusted(engineMessage, { max: MESSAGE_DISPLAY_MAX });
+        return engineMessageLine(engineMessage);
     });
     add('mandated', () => (approvalIsMandated(card) ? mandatedApprovalDetailOf(card, lang) : undefined));
     add('mandate', () => {

package/dist/hitl/approvalRequestFrameReading.d.ts

@@ -0,0 +1,21 @@
+export declare const APPROVAL_REQUEST_FRAME_UNREADABLE_WHYS: readonly ["version_unknown", "kind_unknown", "unreadable_fields"];
+export type ApprovalRequestFrameUnreadableWhy = (typeof APPROVAL_REQUEST_FRAME_UNREADABLE_WHYS)[number];
+export type ApprovalRequestFrameReading = {
+    readonly v1: true;
+} | {
+    readonly v1: false;
+    readonly why: ApprovalRequestFrameUnreadableWhy;
+    readonly schemaVersion?: string;
+    readonly kind?: string;
+};
+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

@@ -0,0 +1,90 @@
+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;
+const KNOWN_KIND = 'permission';
+const FRAME_READING_VALUE_MAX = 24;
+const FRAME_READING_VALUE_PREFIX = 128;
+const V1_READING = Object.freeze({ v1: true });
+const UNREADABLE_READING = Object.freeze({ v1: false, why: 'unreadable_fields' });
+function displayableScalar(v) {
+    let raw;
+    if (typeof v === 'string')
+        raw = v.length > FRAME_READING_VALUE_PREFIX ? v.slice(0, FRAME_READING_VALUE_PREFIX) : v;
+    else if (typeof v === 'number' && Number.isFinite(v))
+        raw = String(v);
+    else
+        return undefined;
+    const shown = displayUntrusted(raw, { max: FRAME_READING_VALUE_MAX });
+    return shown === '' ? undefined : shown;
+}
+export function approvalRequestFrameReadingThrowing(frame) {
+    if (typeof frame !== 'object' || frame === null)
+        return UNREADABLE_READING;
+    const x = frame;
+    const type = x.type;
+    const schemaVersion = x.schemaVersion;
+    const kind = x.kind;
+    const pinned = Object.create(frame, {
+        type: { value: type, enumerable: true },
+        schemaVersion: { value: schemaVersion, enumerable: true },
+        kind: { value: kind, enumerable: true },
+    });
+    if (isApprovalRequestFrameV1(pinned))
+        return V1_READING;
+    const why = type !== KNOWN_FRAME_TYPE
+        ? 'unreadable_fields'
+        : schemaVersion !== KNOWN_SCHEMA_VERSION
+            ? 'version_unknown'
+            : kind !== KNOWN_KIND
+                ? 'kind_unknown'
+                : 'unreadable_fields';
+    const shownVersion = displayableScalar(schemaVersion);
+    const shownKind = displayableScalar(kind);
+    return Object.freeze({
+        v1: false,
+        why,
+        ...(shownVersion !== undefined ? { schemaVersion: shownVersion } : {}),
+        ...(shownKind !== undefined ? { kind: shownKind } : {}),
+    });
+}
+export function approvalRequestFrameReadingOf(frame) {
+    try {
+        return approvalRequestFrameReadingThrowing(frame);
+    }
+    catch {
+        return UNREADABLE_READING;
+    }
+}
+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)
+            return undefined;
+        const v1 = Object.getOwnPropertyDescriptor(reading, 'v1');
+        const why = Object.getOwnPropertyDescriptor(reading, 'why');
+        if (v1 === undefined || !Object.hasOwn(v1, 'value') || v1.value !== false)
+            return undefined;
+        if (why === undefined || !Object.hasOwn(why, 'value'))
+            return undefined;
+        const word = why.value;
+        return typeof word === 'string' ? approvalUnreadableWhyWordOf(word) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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 {

package/dist/hitl/approvalResolution.js

@@ -16,6 +16,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 +28,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';
 }

package/dist/hitl/approvalsFeed.js

@@ -51,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), JSON.stringify(parkRowDelegationLinksOf(r) ?? null)]
+        .map(r => [r.sessionId ?? '', r.taskId ?? '', r.toolCallId ?? '', r.boundCallId ?? '', r.boundInputHash ?? '', r.toolName ?? '', r.gateKind ?? '', JSON.stringify(checkpointRowVerdictOf(r) ?? null), JSON.stringify(parkRowDelegationLinksOf(r) ?? null)]
         .join('
'))
         .sort()
         .join('');

package/dist/hitl/askGateWire.js

@@ -91,7 +91,6 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
                     await abortableSleep(reopenAfterMs, opts?.signal ?? new AbortController().signal);
                     if (!opts?.signal?.aborted) {
                         const seq = led.lastSeq();
-                        led.beginStreamSegment();
                         stream = deps.runsEvents(taskId.current, {
                             ...(seq !== undefined ? { lastEventId: seq } : {}),
                             ...(opts?.signal ? { signal: opts.signal } : {}),
@@ -170,7 +169,6 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             led.forgetRunScopedState();
         }
         const seq = handoff !== undefined ? undefined : led.lastSeq();
-        led.beginStreamSegment();
         stream = deps.runsEvents(taskId.current, {
             ...(seq !== undefined ? { lastEventId: seq } : {}),
             ...(opts?.signal ? { signal: opts.signal } : {}),

package/dist/hitl/askParkRowRouting.js

@@ -1,7 +1,7 @@
 import { askParkForeignGateKind, durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
 import { isAskTool, questionCardVerdict } from './frameRouter.js';
 import { approvalCallKey } from './gateIdentity.js';
-import { askQuestionsFromPending, pendingRowIsOwnedByThisSession } from './parkOwnership.js';
+import { askQuestionsFromPending, pendingRowIsOwnedByThisSession, pendingRowOwnershipOf } 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';
@@ -161,8 +161,11 @@ export function countOwnedPendingRows(listed, deps) {
             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')
+        if (family === 'unreadable') {
+            if (pendingRowOwnershipOf(row, deps) === 'foreign')
+                continue;
             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))

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -1,13 +1,15 @@
 import { type CoreModeArbitrationRow } from '../generated/engineFactTables.js';
 import { CORE_ASK_FACES } from '../generated/engineAskFaceTables.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
+import type { PermissionRuleValue } from '@sema-agent/agent-types';
 export type AutomaticAnswerLane = 'mode_posture' | 'standing_rule' | 'permission_request_hook';
 export type AutomaticAnswerAskFace = (typeof CORE_ASK_FACES)[number];
 export interface AutomaticAnswerFacts {
     readonly settingsAskRuleMatched?: boolean;
+    readonly allowRule?: PermissionRuleValue;
 }
 export type AutomaticAnswerRoad = 'origin' | 'requires_real_approval' | 'governance' | 'mandate_word' | 'mandated' | 'allow_rule_shadow' | 'ask_class' | 'settings_ask_rule';
-export type AutomaticAnswerUnknownWhy = 'card_unreadable' | 'lane_not_recognised' | 'classes_malformed' | 'classes_absent' | 'class_not_in_table' | 'host_not_reported';
+export type AutomaticAnswerUnknownWhy = 'card_unreadable' | 'lane_not_recognised' | 'classes_malformed' | 'classes_absent' | 'class_not_in_table' | 'host_not_reported' | 'answer_may_read_arguments';
 export type AutomaticAnswerVerdict = {
     readonly kind: 'must_ask';
     readonly road: AutomaticAnswerRoad;
@@ -22,6 +24,7 @@ export type AutomaticAnswerVerdict = {
 };
 export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "target_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "unverifiable_shell_text" | "transcript_write" | "org_rule" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "cross_boundary" | "operator_forced" | "shell_floor" | "probe" | "write_protection_on_disk" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
 export declare function foldModeArbitrationRow(classes: Iterable<string>, askFace?: AutomaticAnswerAskFace): CoreModeArbitrationRow;
+export declare function askLevelVerdict(card: object | null | undefined, lane: AutomaticAnswerLane, facts?: AutomaticAnswerFacts | null): AutomaticAnswerVerdict;
 export declare function automaticAnswerVerdict(card: object | null | undefined, lane: AutomaticAnswerLane, facts?: AutomaticAnswerFacts | null): AutomaticAnswerVerdict;
 export declare function mandatedApprovalDetailOf(card: object | null | undefined, lang?: UiLanguage): string;
 export interface CrossBoundaryTaintReading {
@@ -29,5 +32,5 @@ export interface CrossBoundaryTaintReading {
 }
 export declare function crossBoundaryTaintOf(carrier: object | null | undefined): CrossBoundaryTaintReading | undefined;
 export declare function crossBoundaryTaintWayOutOf(carrier: object | null | undefined, lang?: UiLanguage): string | undefined;
-export type PermissionRequestHookScope = 'allow_or_deny' | 'deny_only' | 'skip';
+export type PermissionRequestHookScope = 'deny_only' | 'skip';
 export declare function permissionRequestHookScope(verdict: AutomaticAnswerVerdict | null | undefined): PermissionRequestHookScope;

package/dist/hitl/automaticAnswerVerdict.js

@@ -3,6 +3,7 @@ import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from
 import { mandatedApprovalDetail } from '../gateVocabulary.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { guardedRead, readAskOrigin, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
+import { allowRuleScopeOf } from './permissionRuleScope.js';
 import { readAskClassPairState } from './askClassPair.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
 import { approvalAllowRuleShadowed, retiredAllowRuleShadowKeyPresent } from './allowRuleShadow.js';
@@ -60,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 } : {}) });
@@ -78,6 +79,7 @@ const UNKNOWN = Object.freeze({
     classes_absent: Object.freeze({ kind: 'unknown', why: 'classes_absent' }),
     class_not_in_table: Object.freeze({ kind: 'unknown', why: 'class_not_in_table' }),
     host_not_reported: Object.freeze({ kind: 'unknown', why: 'host_not_reported' }),
+    answer_may_read_arguments: Object.freeze({ kind: 'unknown', why: 'answer_may_read_arguments' }),
 });
 const MAY_ANSWER = Object.freeze({ kind: 'may_answer' });
 function evidenceView(card, ...keys) {
@@ -142,7 +144,7 @@ function readHostAskRuleMatched(facts) {
     const v = guardedRead(() => readOwnDataValue(facts, 'settingsAskRuleMatched'));
     return typeof v === 'boolean' ? v : undefined;
 }
-export function automaticAnswerVerdict(card, lane, facts) {
+export function askLevelVerdict(card, lane, facts) {
     if (lane !== 'mode_posture' && lane !== 'standing_rule' && lane !== 'permission_request_hook')
         return UNKNOWN.lane_not_recognised;
     try {
@@ -214,6 +216,18 @@ export function automaticAnswerVerdict(card, lane, facts) {
         return UNKNOWN.card_unreadable;
     }
 }
+function reportedWholeToolAllowRule(facts) {
+    if (typeof facts !== 'object' || facts === null)
+        return false;
+    const raw = guardedRead(() => readOwnDataValue(facts, 'allowRule'));
+    return allowRuleScopeOf(typeof raw === 'object' ? raw : undefined) === 'whole_tool';
+}
+export function automaticAnswerVerdict(card, lane, facts) {
+    const asked = askLevelVerdict(card, lane, facts);
+    if (asked.kind !== 'may_answer' || lane === 'mode_posture')
+        return asked;
+    return lane === 'standing_rule' && reportedWholeToolAllowRule(facts) ? asked : UNKNOWN.answer_may_read_arguments;
+}
 export function mandatedApprovalDetailOf(card, lang) {
     try {
         if (typeof card !== 'object' || card === null)
@@ -276,7 +290,7 @@ export function crossBoundaryTaintWayOutOf(carrier, lang) {
 export function permissionRequestHookScope(verdict) {
     try {
         const kind = typeof verdict === 'object' && verdict !== null ? verdict.kind : undefined;
-        return kind === 'may_answer' ? 'allow_or_deny' : kind === 'must_ask' ? 'skip' : 'deny_only';
+        return kind === 'must_ask' ? 'skip' : 'deny_only';
     }
     catch {
         return 'deny_only';

package/dist/hitl/decisionConflict.d.ts

@@ -3,5 +3,6 @@ import type { CapturedCode } from '../engineWireFor.js';
 import { type ProtocolErrorNameReading } from '../wireFailureShape.js';
 export type DecisionRefusalConflict = 'binding_mismatch' | 'row_integrity' | 'format_version' | 'answer_invalid' | 'grant_changed';
 export declare function decisionConflictOf(err: unknown, captured?: CapturedCode, protocolNameRead?: ProtocolErrorNameReading): DecisionRefusalConflict | undefined;
-export declare const DECISION_ANSWER_INVALID_CONTENT = "The engine rejected the answer itself because it does not fit the question that was asked \u00B7 Nothing was decided and the question is still waiting \u00B7 Correct the answer and send it again";
+export declare function decisionAnswerInvalidContent(lang?: UiLanguage): string;
+export declare const DECISION_ANSWER_INVALID_CONTENT: string;
 export declare function decisionGrantChangedContent(lang?: UiLanguage): string;

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;
@@ -45,7 +48,10 @@ export function decisionConflictOf(err, captured, protocolNameRead) {
     }
     return BINDING_SEAT_FIELDS.has(field) ? 'binding_mismatch' : undefined;
 }
-export const DECISION_ANSWER_INVALID_CONTENT = 'The engine rejected the answer itself because it does not fit the question that was asked · Nothing was decided and the question is still waiting · Correct the answer and send it again';
+export function decisionAnswerInvalidContent(lang) {
+    return renderMessage(msg('approval.decision.answerInvalid'), lang);
+}
+export const DECISION_ANSWER_INVALID_CONTENT = decisionAnswerInvalidContent();
 export function decisionGrantChangedContent(lang) {
     return renderMessage(msg('approval.decision.grantChanged'), lang);
 }

package/dist/hitl/decisionRefusal.js

@@ -226,6 +226,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/decisionSend.d.ts

@@ -1,5 +1,6 @@
 import type { AgentClient, ElicitResponse } from '@sema-agent/sdk';
 import type { UiLanguage } from '../env/uiLanguage.js';
+import type { ToolPermissionSettledElsewhere } from './approvalResolution.js';
 import { type AskGoneDetail } from '../decideReceipt.js';
 import type { ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecisionNoteAudit } from './approvalDecisionNoteAudit.js';
@@ -64,6 +65,7 @@ interface HitlDecisionOutcomeBase {
     readonly attempts: number;
     readonly fallback?: 'approval';
     readonly noteDropped?: true;
+    readonly allowNoteDropped?: true;
     readonly rememberDropped?: true;
     readonly allowSessionCarried?: true;
     readonly attributionDropped?: true;
@@ -115,5 +117,6 @@ export interface HitlDecisionSendTiming {
 export declare function __setHitlDecisionSendTimingForTests(t?: HitlDecisionSendTiming): void;
 export declare function hitlAskIdempotencyKey(askId: string, verdict: 'approve' | 'deny'): string;
 export declare function sendHitlDecision(request: HitlDecisionSendRequest, deps: HitlDecisionSendDeps): Promise<HitlDecisionSendOutcome>;
+export declare function toolPermissionSettledLine(fact: ToolPermissionSettledElsewhere | null | undefined, lang?: UiLanguage): string | undefined;
 export declare function hitlDecisionOutcomeContent(outcome: HitlDecisionSendOutcome, lang?: UiLanguage): string | undefined;
 export {};

package/dist/hitl/decisionSend.js

@@ -14,7 +14,7 @@ import { ASK_DECIDED_CODE, classifyDeliveredDecisionRefusal, decisionRefusalClos
 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';
+import { allowNoteReadingOf, answerPayloadFor, decisionAttributionKeyOf, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, replayedFirstDecisionOf, settlementAckOf, } from './toolApprovalWire.js';
 export const HITL_DECISION_FAMILIES = Object.freeze(['approval', 'ask', 'elicitation']);
 export const HITL_DECISION_NOT_APPLIED_CAUSES = Object.freeze(['gone', 'parked', 'parking', 'lane_disabled', 'refused', 'idempotency_crossed']);
 export const HITL_DECISION_UNCONFIRMED_CAUSES = Object.freeze(['transport', 'server_error', 'local_error', 'aborted', 'gone_after_retry']);
@@ -163,9 +163,10 @@ async function sendApprovalFamily(respond, approvalId, answer, ctx) {
         const hint = view !== undefined ? ownReadingSlot(view, 'retryAfterMs') : undefined;
         return { ...base, kind: 'not_applied', cause: 'parking', ...(view !== undefined ? { parking: view, ...(hint !== undefined ? { retryAfterMs: hint } : {}) } : {}) };
     }
-    const parsed = readToolApprovalRespondAck(raw);
-    if (parsed !== undefined && isToolApprovalRespondReplayed(parsed)) {
-        const first = parsed.approvalId === approvalId ? verdictOf(parsed.decision) : undefined;
+    const parsed = settlementAckOf(readToolApprovalRespondAck(raw));
+    const replayWord = replayedFirstDecisionOf(parsed);
+    if (parsed !== undefined && replayWord !== undefined) {
+        const first = parsed.approvalId === approvalId ? verdictOf(replayWord) : undefined;
         return {
             ...base,
             kind: 'settled_elsewhere',
@@ -183,6 +184,7 @@ function bodyFacts(answer, payload, rememberUnsupported) {
     return {
         ...(reason !== undefined && reason.trim() !== '' && payload.note === undefined ? { noteDropped: true } : {}),
         ...(rememberUnsupported && answer.kind === 'allow' && answer.allowSession === true ? { rememberDropped: true } : {}),
+        ...(answer.kind === 'allow' && allowNoteReadingOf(answer).kind === 'text' ? { allowNoteDropped: true } : {}),
     };
 }
 function answerGateCannotTake(out) {
@@ -361,8 +363,10 @@ function snapshotAnswer(raw) {
     if (kind === 'allow') {
         const allowSession = guardedRead(() => readOwnDataValue(raw, 'allowSession')) === true;
         const edited = guardedRead(() => readOwnDataValue(raw, 'updatedInput'));
+        const noteRaw = guardedRead(() => readOwnDataValue(raw, 'note'));
+        const note = typeof noteRaw === 'string' && noteRaw.trim() !== '' ? noteRaw : undefined;
         if (edited === undefined)
-            return Object.freeze({ kind: 'allow', allowSession });
+            return Object.freeze({ kind: 'allow', allowSession, ...(note !== undefined ? { note } : {}) });
         let copy;
         try {
             const text = JSON.stringify(edited);
@@ -373,7 +377,7 @@ function snapshotAnswer(raw) {
         catch {
             return undefined;
         }
-        return Object.freeze({ kind: 'allow', allowSession, updatedInput: copy });
+        return Object.freeze({ kind: 'allow', allowSession, ...(note !== undefined ? { note } : {}), updatedInput: copy });
     }
     if (kind === 'deny') {
         const reason = guardedRead(() => readOwnDataValue(raw, 'reason'));
@@ -560,6 +564,24 @@ export async function sendHitlDecision(request, deps) {
         ownHold.release(out.kind === 'applied' || out.kind === 'settled_elsewhere' ? 'answered' : undefined);
     return Object.freeze(out);
 }
+function settledElsewhereContraryContent(first, lang) {
+    return first === 'deny'
+        ? renderMessage(msg('approval.decision.settledElsewhereContrary.deniedFirst'), lang)
+        : renderMessage(msg('approval.decision.settledElsewhereContrary.approvedFirst'), lang);
+}
+export function toolPermissionSettledLine(fact, lang) {
+    try {
+        if (typeof fact !== 'object' || fact === null)
+            return undefined;
+        if (readOwnDataValue(fact, 'contrary') !== true)
+            return undefined;
+        const first = readOwnDataValue(fact, 'firstDecision');
+        return first === 'allow' || first === 'deny' ? settledElsewhereContraryContent(first, lang) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function hitlDecisionOutcomeContent(outcome, lang) {
     try {
         if (typeof outcome !== 'object' || outcome === null)
@@ -569,11 +591,7 @@ export function hitlDecisionOutcomeContent(outcome, lang) {
             if (readOwnDataValue(outcome, 'contrary') !== true)
                 return undefined;
             const first = readOwnDataValue(outcome, 'firstDecision');
-            if (first === 'deny')
-                return renderMessage(msg('approval.decision.settledElsewhereContrary.deniedFirst'), lang);
-            if (first === 'approve')
-                return renderMessage(msg('approval.decision.settledElsewhereContrary.approvedFirst'), lang);
-            return undefined;
+            return first === 'deny' || first === 'approve' ? settledElsewhereContraryContent(first, lang) : undefined;
         }
         if (kind === 'unconfirmed' && readOwnDataValue(outcome, 'cause') === 'gone_after_retry')
             return renderMessage(msg('approval.decision.unconfirmedAfterRetry'), lang);

package/dist/hitl/editedApprovalAcceptance.d.ts

@@ -0,0 +1,25 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
+export declare const EDITED_APPROVAL_STATES: readonly ["accepts", "refuses", "unknown"];
+export type EditedApprovalState = (typeof EDITED_APPROVAL_STATES)[number];
+export declare const EDITED_APPROVAL_BASES: Readonly<{
+    accepts: readonly ["args_available"];
+    refuses: readonly ["args_unavailable"];
+    unknown: readonly ["card_unreadable", "slot_unreadable", "slot_malformed"];
+}>;
+interface EditedApprovalAccepts {
+    readonly state: 'accepts';
+    readonly basis: (typeof EDITED_APPROVAL_BASES.accepts)[number];
+}
+interface EditedApprovalRefuses {
+    readonly state: 'refuses';
+    readonly basis: (typeof EDITED_APPROVAL_BASES.refuses)[number];
+    readonly askStaysPending: true;
+}
+interface EditedApprovalUnknown {
+    readonly state: 'unknown';
+    readonly basis: (typeof EDITED_APPROVAL_BASES.unknown)[number];
+}
+export type EditedApprovalAcceptance = EditedApprovalAccepts | EditedApprovalRefuses | EditedApprovalUnknown;
+export declare function editedApprovalAcceptanceOf(card: {} | null | undefined): EditedApprovalAcceptance;
+export declare function editedApprovalRefusedLine(lang?: UiLanguage): string;
+export {};

package/dist/hitl/editedApprovalAcceptance.js

@@ -0,0 +1,26 @@
+import { msg, renderMessage } from '../i18n/translate.js';
+import { slotReadOf } from '../wireFailureShape.js';
+export const EDITED_APPROVAL_STATES = Object.freeze(['accepts', 'refuses', 'unknown']);
+export const EDITED_APPROVAL_BASES = Object.freeze({
+    accepts: Object.freeze(['args_available']),
+    refuses: Object.freeze(['args_unavailable']),
+    unknown: Object.freeze(['card_unreadable', 'slot_unreadable', 'slot_malformed']),
+});
+const ACCEPTS = Object.freeze({ state: 'accepts', basis: 'args_available' });
+const REFUSES = Object.freeze({ state: 'refuses', basis: 'args_unavailable', askStaysPending: true });
+const UNKNOWN_CARD = Object.freeze({ state: 'unknown', basis: 'card_unreadable' });
+const UNKNOWN_SLOT = Object.freeze({ state: 'unknown', basis: 'slot_unreadable' });
+const UNKNOWN_MALFORMED = Object.freeze({ state: 'unknown', basis: 'slot_malformed' });
+export function editedApprovalAcceptanceOf(card) {
+    if (typeof card !== 'object' || card === null)
+        return UNKNOWN_CARD;
+    const read = slotReadOf(card, 'argsUnavailable');
+    if (read.presence === 'unreadable')
+        return UNKNOWN_SLOT;
+    if (read.presence === 'absent' || read.value === undefined)
+        return ACCEPTS;
+    return read.value === true ? REFUSES : UNKNOWN_MALFORMED;
+}
+export function editedApprovalRefusedLine(lang) {
+    return renderMessage(msg('approval.editRefusal.line'), lang);
+}