@sema-agent/client-core 0.109.0 → 0.110.0

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 {

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/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/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.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);
+}

package/dist/hitl/frameRouter.js

@@ -10,13 +10,13 @@ import { guardedRead, readOwnDataValue } from '../ownKey.js';
 import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { surfaceForCurrentSession, surfaceReplayedApprovalListUnreadable } from './hitlHostSurface.js';
-import { liveCardHoldOf, noteEngineClosedApproval, settleEngineClosedApproval } from './approvalHolds.js';
+import { liveCardHoldOf, settleEngineClosedApproval } from './approvalHolds.js';
 import { approvalCompleteParked } from './approvalCompleteParked.js';
 import { liveFrameCallKey } from './gateIdentity.js';
 import { readPolicyDenyCause } from './policyDenyCause.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { SEMA_DENIAL_KIND_KEY, hasLedgerPositionKey } from './gateLedger.js';
-import { replayedApprovalClosesCardFrame, replayedApprovalDisposition, settledApprovalDisposition } from './replayedApproval.js';
+import { replayedApprovalDisposition, settledApprovalDisposition } from './replayedApproval.js';
 import { settleWithinDeadline } from '../abortableSleep.js';
 import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
 import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
@@ -349,7 +349,7 @@ async function routeToolApprovalFrame(ev, ctx) {
         return { kind: 'skip' };
     }
     const settledHere = settledApprovalDisposition(ev);
-    if (settledHere !== undefined || (hasLedgerPositionKey(ev) && !led.preambleApprovals().has(ev.approvalId))) {
+    if (settledHere !== undefined || hasLedgerPositionKey(ev)) {
         const disposition = settledHere ?? (await judgeLedgerApprovalFrame(ev, ctx));
         if (disposition.kind !== 'live') {
             hostLog('debug', disposition.kind === 'decided' && disposition.settled !== undefined
@@ -357,8 +357,6 @@ async function routeToolApprovalFrame(ev, ctx) {
                 : `liveHitlAskWire: tool_approval frame ${ev.approvalId} read back from the run event log is ${disposition.kind}` +
                     `${disposition.kind === 'unknown' ? ` (${disposition.why})` : disposition.cause !== undefined ? ` (${disposition.cause})` : ''}` +
                     ' — not raised as a question, no decision sent');
-            if (settledHere === undefined && replayedApprovalClosesCardFrame(disposition))
-                noteEngineClosedApproval(ev.approvalId, false);
             if (disposition.kind === 'unknown' && ctx.signal?.aborted !== true)
                 surfaceReplayedApprovalListUnreadable();
             if (deps.onReplayedApproval !== undefined) {
@@ -416,7 +414,7 @@ async function judgeLedgerApprovalFrame(ev, ctx) {
             .finally(release);
     });
     const approvals = got.kind === 'value' ? { read: 'ok', body: got.value } : { read: 'failed' };
-    return replayedApprovalDisposition(ev, { preamble: ctx.led.preambleApprovals(), approvals });
+    return replayedApprovalDisposition(ev, { approvals });
 }
 function routeToolStart(ev, callId, led) {
     led.noteStart(callId, ev);
@@ -511,17 +509,5 @@ export async function routeFrame(ev, ctx) {
     if (ev.type === 'failed') {
         return { kind: 'end', events: [...flushHeldWithInterruptRewrite(led, { terminal: ev, signal: ctx.signal }), ev] };
     }
-    if (ev.type === 'approval_request') {
-        try {
-            if (!hasLedgerPositionKey(ev)) {
-                const id = ev.approvalId;
-                if (typeof id === 'string' && id !== '')
-                    led.notePreambleApproval(id);
-            }
-        }
-        catch (e) {
-            hostLog('debug', `liveHitlAskWire: approval_request frame unreadable — not counted as preamble evidence: ${String(e).slice(0, 120)}`);
-        }
-    }
     return { kind: 'yield', events: [ev] };
 }

package/dist/hitl/gateLedger.d.ts

@@ -18,14 +18,10 @@ export interface AskAnsweredOutput {
 export declare function durableSeqOf(ev: object): string | undefined;
 export declare const BODY_SEQ_OTHER_AXIS_EVENTS: readonly string[];
 export declare function hasLedgerPositionKey(ev: object): boolean;
-export declare const PREAMBLE_APPROVALS_MAX_ENTRIES = 4096;
 export interface GateLedger {
     noteSeq(ev: AgentEvent): void;
     lastSeq(): string | undefined;
     forgetRunScopedState(): void;
-    notePreambleApproval(approvalId: string): void;
-    preambleApprovals(): ReadonlySet<string>;
-    beginStreamSegment(): void;
     trackLiveCard(phaseOf: () => 'card' | 'respond', handled: Promise<void>): void;
     answeringLiveCards(): Promise<void>[];
     liveCardsSettled(): Promise<void>;

package/dist/hitl/gateLedger.js

@@ -21,7 +21,6 @@ export function hasLedgerPositionKey(ev) {
     const { id, seq } = ev;
     return (id !== undefined && id !== null) || (seq !== undefined && seq !== null);
 }
-export const PREAMBLE_APPROVALS_MAX_ENTRIES = 4096;
 export const START_ARGS_MAX_ENTRIES = 256;
 function normalizeDenyAttribution(a) {
     if (a === undefined)
@@ -108,7 +107,6 @@ export function createGateLedger() {
     let denyStampNextFsEnd = false;
     let denyStampAttribution;
     let seq;
-    const preambleApprovalIds = new Set();
     const liveCards = new Set();
     return {
         noteSeq(ev) {
@@ -125,23 +123,6 @@ export function createGateLedger() {
             startArgsByCall.clear();
             gatedStartCalls.clear();
         },
-        notePreambleApproval(approvalId) {
-            if (typeof approvalId !== 'string' || approvalId === '')
-                return;
-            preambleApprovalIds.delete(approvalId);
-            preambleApprovalIds.add(approvalId);
-            if (preambleApprovalIds.size > PREAMBLE_APPROVALS_MAX_ENTRIES) {
-                const oldest = preambleApprovalIds.values().next().value;
-                if (oldest !== undefined)
-                    preambleApprovalIds.delete(oldest);
-            }
-        },
-        preambleApprovals() {
-            return preambleApprovalIds;
-        },
-        beginStreamSegment() {
-            preambleApprovalIds.clear();
-        },
         trackLiveCard(phaseOf, handled) {
             const entry = { phaseOf, handled };
             liveCards.add(entry);

package/dist/hitl/hitlBridge.d.ts

@@ -160,6 +160,7 @@ export declare class HitlBridge {
         decision: 'approve';
         updatedInput?: unknown;
         remember?: 'session' | undefined;
+        feedback?: string | undefined;
     } | HitlDecideDenyOutcome, toolUseID?: string, opts?: {
         signal?: AbortSignal;
         operation?: DecideOperationSpan;

package/dist/hitl/hitlBridge.js

@@ -385,6 +385,7 @@ export class HitlBridge {
                 ...this.bindingOf(pending),
                 ...(outcome.updatedInput !== undefined ? { updatedInput: outcome.updatedInput } : {}),
                 ...(outcome.remember !== undefined ? { remember: outcome.remember } : {}),
+                ...(outcome.feedback !== undefined ? { feedback: outcome.feedback } : {}),
             }
             : {
                 decision: 'deny',
@@ -598,12 +599,11 @@ function bindingMismatchReading(e) {
         return 'not';
     const code = readWireErrorCodeReading(e);
     const nameReading = protocolErrorNameReading(e);
-    const family = (code.state === 'code' && (code.code === APPROVAL_BINDING_MISMATCH || code.code === CHECKPOINT_INVALID_OUTCOME)) ||
-        (nameReading.state === 'named' && nameReading.name === PROTOCOL_ERROR_NAME.ApprovalBindingMismatchError);
+    const codeReclassified = code.state === 'code' && code.code === CHECKPOINT_INVALID_OUTCOME;
+    const family = (code.state === 'code' && code.code === APPROVAL_BINDING_MISMATCH) ||
+        (!codeReclassified && nameReading.state === 'named' && nameReading.name === PROTOCOL_ERROR_NAME.ApprovalBindingMismatchError);
     if (family)
         return 'mismatch';
-    if (nameReading.state === 'sdk-instance' && code.state !== 'code')
-        return 'unreadable';
     if (code.state === 'unreadable')
         return 'unreadable';
     return 'not';

package/dist/hitl/hitlHostSurface.d.ts

@@ -28,6 +28,7 @@ export declare const CANCEL_DENY_WARN_TEXT = "could not cancel the pending quest
 export declare const REMEMBER_NOT_APPLIED_WARN_TEXT = "this session-wide allow was not remembered by the worker \u2014 you will be asked again for this tool";
 export declare const EDIT_NOT_FORWARDED_WARN_TEXT = "your edited tool input was NOT forwarded \u2014 the tool is running with the ORIGINAL input you saw before editing";
 export declare function surfaceRememberNotApplied(): void;
+export declare function surfaceAllowNoteNotCarried(sentence: string): void;
 export declare function surfaceEditNotForwarded(): void;
 export declare const APPROVAL_PARKING_WARN_TEXT = "This approval is being parked; answer it again on the parked card when it appears.";
 export declare function approvalParkingNoticeText(retryAfterMs?: number): string;

package/dist/hitl/hitlHostSurface.js

@@ -2,6 +2,7 @@ import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
 import { decideFailureNote } from '../decideFailureNote.js';
+import { editedApprovalRefusedLine } from './editedApprovalAcceptance.js';
 import { decisionRefusalSaysAskGone } from './decisionRefusal.js';
 const hostSurfaceByKey = createSessionSlot();
 const hostSurfaceMissesByKey = new Map();
@@ -73,6 +74,11 @@ const EDIT_NOT_FORWARDED_TIMEOUT_MS = 20_000;
 export function surfaceRememberNotApplied() {
     surfaceSelfClearingWarn(REMEMBER_NOT_APPLIED_KEY, REMEMBER_NOT_APPLIED_WARN_TEXT, REMEMBER_NOT_APPLIED_TIMEOUT_MS);
 }
+const ALLOW_NOTE_NOT_CARRIED_KEY = 'hitl-allow-note-not-carried';
+const ALLOW_NOTE_NOT_CARRIED_TIMEOUT_MS = 10_000;
+export function surfaceAllowNoteNotCarried(sentence) {
+    surfaceSelfClearingWarn(ALLOW_NOTE_NOT_CARRIED_KEY, sentence, ALLOW_NOTE_NOT_CARRIED_TIMEOUT_MS);
+}
 export function surfaceEditNotForwarded() {
     surfaceSelfClearingWarn(EDIT_NOT_FORWARDED_KEY, EDIT_NOT_FORWARDED_WARN_TEXT, EDIT_NOT_FORWARDED_TIMEOUT_MS);
 }
@@ -100,8 +106,7 @@ const REPLAYED_APPROVAL_LIST_UNREADABLE_TIMEOUT_MS = 10_000;
 export function surfaceReplayedApprovalListUnreadable() {
     surfaceSelfClearingWarn(REPLAYED_APPROVAL_LIST_UNREADABLE_KEY, REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT, REPLAYED_APPROVAL_LIST_UNREADABLE_TIMEOUT_MS);
 }
-export const EDIT_REFUSED_ON_BLIND_ASK_WARN_TEXT = 'That approval was NOT sent: this request does not expose its tool arguments here, so an edited approval cannot be applied. ' +
-    'The request is still waiting — approve or deny it as it is.';
+export const EDIT_REFUSED_ON_BLIND_ASK_WARN_TEXT = editedApprovalRefusedLine();
 const EDIT_REFUSED_ON_BLIND_ASK_KEY = 'hitl-edit-refused-blind-ask';
 export function surfaceEditRefusedOnBlindAsk() {
     surfaceSelfClearingWarn(EDIT_REFUSED_ON_BLIND_ASK_KEY, EDIT_REFUSED_ON_BLIND_ASK_WARN_TEXT, EDIT_NOT_FORWARDED_TIMEOUT_MS);

package/dist/hitl/hostWithdrawal.d.ts

@@ -0,0 +1,15 @@
+import { type CheckpointRowBar } from '../checkpointRowVerdict.js';
+export interface HostWithdrawal {
+    readonly toldBy: 'host';
+    readonly rowVerdict: CheckpointRowBar;
+}
+export declare function hostWithdrawalOf(v: object | null | undefined): HostWithdrawal | undefined;
+export declare const PARK_QUESTION_WITHDRAW_REFUSALS: readonly ["malformed", "no_card", "not_withdrawable"];
+export type ParkQuestionWithdrawRefusal = (typeof PARK_QUESTION_WITHDRAW_REFUSALS)[number];
+export type ParkQuestionWithdrawal = {
+    readonly withdrawn: true;
+} | {
+    readonly withdrawn: false;
+    readonly refusal: ParkQuestionWithdrawRefusal;
+};
+export declare function withdrawParkQuestion(questionId: string, withdrawal: HostWithdrawal): ParkQuestionWithdrawal;

package/dist/hitl/hostWithdrawal.js

@@ -0,0 +1,38 @@
+import { slotReadOf } from '../wireFailureShape.js';
+import { checkpointRowBarOf } from '../checkpointRowVerdict.js';
+import { takeLocalQuestionWithdrawHook } from '../liveQuestionStore.js';
+import { hostLog } from '../host.js';
+export function hostWithdrawalOf(v) {
+    try {
+        if (typeof v !== 'object' || v === null)
+            return undefined;
+        const told = slotReadOf(v, 'toldBy');
+        if (told.presence !== 'present' || told.value !== 'host')
+            return undefined;
+        if (slotReadOf(v, 'rowVerdict').presence !== 'present')
+            return undefined;
+        const bar = checkpointRowBarOf(v);
+        return bar === undefined ? undefined : Object.freeze({ toldBy: 'host', rowVerdict: bar });
+    }
+    catch {
+        return undefined;
+    }
+}
+export const PARK_QUESTION_WITHDRAW_REFUSALS = Object.freeze(['malformed', 'no_card', 'not_withdrawable']);
+const WITHDRAWN = Object.freeze({ withdrawn: true });
+const refused = (refusal) => Object.freeze({ withdrawn: false, refusal });
+export function withdrawParkQuestion(questionId, withdrawal) {
+    const told = hostWithdrawalOf(withdrawal);
+    if (told === undefined)
+        return refused('malformed');
+    const taken = takeLocalQuestionWithdrawHook(questionId);
+    if (taken === 'no_card' || taken === 'not_withdrawable')
+        return refused(taken);
+    try {
+        taken(told);
+    }
+    catch (e) {
+        hostLog('debug', `hostWithdrawal: withdraw-hook-threw card=${questionId} thrown=${e instanceof Error ? e.name : typeof e}`);
+    }
+    return WITHDRAWN;
+}