@sema-agent/client-core 0.112.0 → 0.113.0

package/dist/hitl/approvalResolution.d.ts

@@ -6,11 +6,13 @@ import type { ApprovalDenySettledBy, ToolApprovalRespondAckView, ToolApprovalRes
 import { type DecisionRefusalReading, type RefusalRouteContext } from './decisionRefusal.js';
 import { type DeliveredReading, type LadderSafetyStop } from './attributionLadder.js';
 import { type CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+import { type ApprovalDecisionDoor } from './approvalDecisionDoor.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", "withdrawn"];
+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", "no_verb", "card_unreadable"];
 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 declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "engine_error", "no_answer", "transport_exhausted", "parking_in_progress", "interrupted", "orchestration", "unreadable", "route_missing"];
 export type ApprovalUnsettledCause = (typeof APPROVAL_UNSETTLED_CAUSES)[number];
 export interface ApprovalDenyFacts {
     readonly settledBy?: ApprovalDenySettledBy;
@@ -45,6 +47,7 @@ export interface ApprovalResolutionNotSent extends ApprovalResolutionBase {
         readonly kind: 'ok';
     }>;
     readonly toldBy?: 'host';
+    readonly door?: ApprovalDecisionDoor;
     readonly detail?: string;
 }
 export interface ApprovalResolutionUnsettled extends ApprovalResolutionBase {
@@ -61,7 +64,7 @@ export declare function approvalNotSentCause(r: ApprovalResolution): ApprovalNot
 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: string;
-export declare function approvalResolutionDetail(r: ApprovalResolution): string | undefined;
+export declare function approvalResolutionDetail(r: ApprovalResolution, lang?: UiLanguage): string | undefined;
 export declare function approvalResolutionStatusTag(r: ApprovalResolution): string;
 export declare function unsettledCauseOfReading(reading: DecisionRefusalReading): 'engine_refused' | 'engine_error' | 'no_answer';
 export interface DecisionFailureMint {

package/dist/hitl/approvalResolution.js

@@ -4,8 +4,10 @@ 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 { ROUTE_NOT_FOUND } from '../engineErrorCodes.js';
 import { CHECKPOINT_ROW_BAR_SENTENCE, unboundWayOutContent } from '../checkpointRowVerdict.js';
 import { msg, renderMessage } from '../i18n/translate.js';
+import { ASK_DECISION_DOOR_SERVER_FROM } from './approvalDecisionDoor.js';
 export const APPROVAL_RESOLUTION_LANES = Object.freeze(['respond', 'decide', 'ask']);
 export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'retracted',
@@ -18,6 +20,8 @@ export const APPROVAL_NOT_SENT_CAUSES = Object.freeze([
     'safety_stop',
     'row_unresumable',
     'withdrawn',
+    'no_verb',
+    'card_unreadable',
 ]);
 export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'engine_refused',
@@ -28,6 +32,7 @@ export const APPROVAL_UNSETTLED_CAUSES = Object.freeze([
     'interrupted',
     'orchestration',
     'unreadable',
+    'route_missing',
 ]);
 export function toolPermissionSettledElsewhereOf(first, sent) {
     return Object.freeze({ firstDecision: first, contrary: (first === 'deny') !== (sent === 'deny') });
@@ -57,6 +62,8 @@ const NOT_SENT_SENTENCES = Object.freeze({
     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,
+    no_verb: renderMessage(msg('approval.notSent.noVerb')),
+    card_unreadable: renderMessage(msg('approval.notSent.cardUnreadable')),
 });
 function nonEmpty(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -72,7 +79,7 @@ function ownStr(o, key) {
         return undefined;
     }
 }
-export function approvalResolutionDetail(r) {
+export function approvalResolutionDetail(r, lang) {
     let kind;
     try {
         kind = typeof r === 'object' && r !== null ? r.kind : undefined;
@@ -80,8 +87,20 @@ export function approvalResolutionDetail(r) {
     catch {
         return undefined;
     }
+    const cause = kind === 'not_sent' || kind === 'unsettled' ? ownStr(r, 'cause') : undefined;
+    if (kind === 'not_sent' && cause === 'no_verb') {
+        return ownStr(r, 'door') === 'respond'
+            ? renderMessage(msg('approval.notSent.noVerbOldServer', { version: ASK_DECISION_DOOR_SERVER_FROM }), lang)
+            : renderMessage(msg('approval.notSent.noVerb'), lang);
+    }
+    if (kind === 'unsettled' && cause === 'route_missing')
+        return renderMessage(msg('approval.routeMissing.line'), lang);
+    if (kind === 'not_sent' && cause === 'card_unreadable')
+        return renderMessage(msg('approval.notSent.cardUnreadable'), lang);
+    return approvalResolutionDataFaceDetail(r, kind, cause);
+}
+function approvalResolutionDataFaceDetail(r, kind, cause) {
     if (kind === 'not_sent') {
-        const cause = ownStr(r, 'cause');
         if (cause === undefined || !Object.hasOwn(NOT_SENT_SENTENCES, cause))
             return undefined;
         const sentence = NOT_SENT_SENTENCES[cause];
@@ -167,6 +186,9 @@ export function resolutionOfDecisionFailure(e, m) {
         return { kind: 'unsettled', ...base, cause: 'engine_refused', safetyCode: 'binding_mismatch', refusal, ...detail };
     if (ownReadingSlot(m, 'transportExhausted') === true || thrownIsInstanceOf(e, DecideTransportRetryExhaustedError))
         return { kind: 'unsettled', ...base, cause: 'transport_exhausted', refusal, ...detail };
+    if (refusal.errorCode === ROUTE_NOT_FOUND && ownReadingSlot(m, 'afterRetry') !== true && ownReadingSlot(refusal, 'standing') !== 'ambiguous') {
+        return { kind: 'unsettled', ...base, cause: 'route_missing', refusal, ...detail };
+    }
     return { kind: 'unsettled', ...base, cause: unsettledCauseOfReading(refusal), refusal, ...detail };
 }
 export function directSafetyStopOf(e) {

package/dist/hitl/approvalsFeed.js

@@ -69,7 +69,7 @@ function digestOf(rows, live, dropped = 0, droppedDurable = 0, peer = []) {
     const liveDigest = live === undefined
         ? 'absent'
         : live
-            .map(r => [r.approvalId, r.toolName, String(r.expiresAtMs), r.sessionId ?? '', r.originTaskId ?? '', r.frame !== undefined ? 'f' : ''].join(LIVE_FIELD_SEP))
+            .map(r => [r.approvalId, r.toolName, String(r.expiresAtMs), r.sessionId ?? '', r.sourceSessionId ?? '', r.frame !== undefined ? 'f' : ''].join(LIVE_FIELD_SEP))
             .sort()
             .join(LIVE_ROW_SEP);
     return `${durableDigestOf(rows)}${LIVE_SECTION_SEP}${liveDigest}${LIVE_SECTION_SEP}${dropped}${LIVE_SECTION_SEP}${droppedDurable}${LIVE_SECTION_SEP}${peerDigestOf(peer)}`;

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -22,7 +22,7 @@ export type AutomaticAnswerVerdict = {
     readonly kind: 'unknown';
     readonly why: AutomaticAnswerUnknownWhy;
 };
-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 const MODE_ARBITRATION: Readonly<Record<"mode" | "hook" | "write_protection" | "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;

package/dist/hitl/decisionSend.d.ts

@@ -5,12 +5,14 @@ import { type ToolPermissionAck } from '../seatContract.js';
 import { type AskGoneDetail } from '../decideReceipt.js';
 import type { ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecisionNoteAudit } from './approvalDecisionNoteAudit.js';
+import type { LegacyToolApprovalRespondVerb } from './legacyApprovalShapes.js';
+import { hitlAskIdempotencyKey, type ApprovalDecisionDoor, type ApprovalDecisionDoorReading } from './approvalDecisionDoor.js';
 import { type DecisionRefusalClassified, type LiveAskPendingReading } from './decisionRefusal.js';
 import { type HostApprovalCardHold } from './approvalHolds.js';
 import { type ApprovalCardDecision, type ToolApprovalRespondAckView, type ToolApprovalRespondParkingView } from './toolApprovalWire.js';
 export declare const HITL_DECISION_FAMILIES: readonly ["approval", "ask", "elicitation"];
 export type HitlDecisionFamily = (typeof HITL_DECISION_FAMILIES)[number];
-export declare const HITL_DECISION_NOT_APPLIED_CAUSES: readonly ["gone", "parked", "parking", "lane_disabled", "refused", "idempotency_crossed"];
+export declare const HITL_DECISION_NOT_APPLIED_CAUSES: readonly ["gone", "parked", "parking", "lane_disabled", "refused", "idempotency_crossed", "route_missing"];
 export type HitlDecisionNotAppliedCause = (typeof HITL_DECISION_NOT_APPLIED_CAUSES)[number];
 export declare const HITL_DECISION_UNCONFIRMED_CAUSES: readonly ["transport", "server_error", "local_error", "aborted", "gone_after_retry"];
 export type HitlDecisionUnconfirmedCause = (typeof HITL_DECISION_UNCONFIRMED_CAUSES)[number];
@@ -45,7 +47,7 @@ export interface HitlElicitationDecisionRequest {
 }
 export type HitlDecisionSendRequest = HitlApprovalDecisionRequest | HitlAskDecisionRequest | HitlElicitationDecisionRequest;
 export interface HitlDecisionSendClient {
-    readonly toolApprovals?: Partial<Pick<AgentClient['toolApprovals'], 'respond' | 'decideAsk'>>;
+    readonly toolApprovals?: Partial<LegacyToolApprovalRespondVerb & Pick<AgentClient['toolApprovals'], 'decideAsk'>>;
     readonly elicitations?: Partial<Pick<AgentClient['elicitations'], 'respond'>>;
 }
 export interface HitlDecisionGate {
@@ -60,6 +62,7 @@ export interface HitlDecisionSendDeps {
     readonly signal?: AbortSignal;
     readonly approvalDecisionNoteCapable?: boolean;
     readonly approvalDecidedBy?: ApprovalDecidedByReading;
+    readonly approvalDecisionDoor?: ApprovalDecisionDoorReading;
     readonly readPending?: (gate: HitlDecisionGate, opts: {
         readonly signal: AbortSignal;
     }) => Promise<LiveAskPendingReading>;
@@ -111,6 +114,7 @@ export interface HitlDecisionUnconfirmed extends HitlDecisionOutcomeBase {
 export interface HitlDecisionNotSent extends HitlDecisionOutcomeBase {
     readonly kind: 'not_sent';
     readonly cause: HitlDecisionNotSentCause;
+    readonly door?: ApprovalDecisionDoor;
 }
 export type HitlDecisionSendOutcome = HitlDecisionApplied | HitlDecisionSettledElsewhere | HitlDecisionNotApplied | HitlDecisionUnconfirmed | HitlDecisionNotSent;
 export declare const HITL_DECISION_READBACK_BUDGET_MS = 4000;
@@ -120,10 +124,9 @@ export interface HitlDecisionSendTiming {
     readonly parkingDelayMs?: number;
 }
 export declare function __setHitlDecisionSendTimingForTests(t?: HitlDecisionSendTiming): void;
-export declare function hitlAskIdempotencyKey(askId: string, verdict: 'approve' | 'deny'): string;
+export { hitlAskIdempotencyKey };
 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 toolPermissionUnconfirmedLine(ack: ToolPermissionAck | null | undefined, lang?: UiLanguage): string | undefined;
 export declare function toolPermissionUnconfirmedOf(thrown: {} | null | undefined, signal?: AbortSignal): ToolPermissionUnconfirmed | undefined;
 export declare function hitlDecisionOutcomeContent(outcome: HitlDecisionSendOutcome, lang?: UiLanguage): string | undefined;
-export {};

package/dist/hitl/decisionSend.js

@@ -6,40 +6,28 @@ import { msg, renderMessage } from '../i18n/translate.js';
 import { askGoneFromError } from '../decideReceipt.js';
 import { appendOwnElement, guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { effectiveCodeOf, ownReadingSlot } from '../engineWireFor.js';
-import { ASK_DECISION_LANE_DISABLED, ASK_GONE, ASK_GONE_PARKED, ASK_IDEMPOTENCY_CONFLICT, ASK_NOT_FOUND, ASK_PARKING_RETRY } from '../engineErrorCodes.js';
-import { isSlotCarrier, readErrorNumber, readErrorString, readThrownSlot } from '../wireFailureShape.js';
+import { ASK_DECISION_LANE_DISABLED, ASK_GONE, ASK_GONE_PARKED, ASK_IDEMPOTENCY_CONFLICT, ASK_NOT_FOUND, ASK_PARKING_RETRY, ROUTE_NOT_FOUND } from '../engineErrorCodes.js';
+import { readErrorNumber, readErrorString, readThrownSlot } from '../wireFailureShape.js';
 import { readDecisionNoteAudit } from './approvalDecisionNoteAudit.js';
+import { approvalDecisionDoorOf, ASK_DECISION_DOOR_SERVER_FROM, ROUTE_MISSING_WIRING_HINT, hitlAskIdempotencyKey, noteRespondDoorSwitch } from './approvalDecisionDoor.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 { budgetSpent, deliverApprovalDecision, retryAfterMsOf, deliveryTiming, isAborted, newSendTally, PARKING_WAIT_CAP_MS, respondRouteGoneOf, setDeliveryTimingForTests, sleepFor, settledTransportReadingOf, withTransportRetry, deliveryReadingOf, } from './approvalDelivery.js';
 import { ASK_DECIDED_CODE, classifyDeliveredDecisionRefusal, decisionRefusalClosesOut, notPendingAfterRetry } from './decisionRefusal.js';
 import { sessionAllowEligible } from './sessionAllowRoute.js';
 import { addDecisionOpKeys, closeDecisionOp, decisionLedgerKeysOf, decisionOpsWithKey, openDecisionOp } from './decisionLedger.js';
 import { hostHoldIsActive, takeHostHoldLedgerOp, tryHoldApprovalNow } from './approvalHolds.js';
-import { allowNoteReadingOf, answerPayloadFor, decisionAttributionKeyOf, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, replayVerdictFrom, settlementAckOf, } from './toolApprovalWire.js';
+import { allowNoteReadingOf, answerPayloadFor, askDoorBodyOf, decisionAttributionKeyOf, readApprovalDenySettledBy, readAskDoorDecisionBody, readToolApprovalRespondAck, readToolApprovalRespondParking, replayVerdictFrom, 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_NOT_APPLIED_CAUSES = Object.freeze(['gone', 'parked', 'parking', 'lane_disabled', 'refused', 'idempotency_crossed', 'route_missing']);
 export const HITL_DECISION_UNCONFIRMED_CAUSES = Object.freeze(['transport', 'server_error', 'local_error', 'aborted', 'gone_after_retry']);
 export const HITL_DECISION_NOT_SENT_CAUSES = Object.freeze(['aborted', 'duplicate_in_flight', 'invalid_request', 'no_verb', 'not_an_answer']);
 const PARKING_POLL_MAX = 2;
 const PARKING_POLL_DELAY_MS = 400;
 export const HITL_DECISION_READBACK_BUDGET_MS = 4_000;
-const IDEMPOTENCY_KEY_MAX = 255;
 export function __setHitlDecisionSendTimingForTests(t) {
     setDeliveryTimingForTests(t);
 }
-export function hitlAskIdempotencyKey(askId, verdict) {
-    const key = `sema-ask:${askId}:${verdict}`;
-    return key.length <= IDEMPOTENCY_KEY_MAX ? key : key.slice(0, IDEMPOTENCY_KEY_MAX);
-}
-function retryAfterMsOf(e) {
-    if (!isSlotCarrier(e))
-        return undefined;
-    const ms = readErrorNumber(e, 'retryAfterMs');
-    if (ms !== undefined && Number.isFinite(ms) && ms >= 0)
-        return ms;
-    const sec = readErrorNumber(e, 'retryAfterSec');
-    return sec !== undefined && Number.isFinite(sec) && sec >= 0 ? sec * 1000 : undefined;
-}
+export { hitlAskIdempotencyKey };
 function actorLabelOf(e) {
     const actor = readThrownSlot(e, 'actor', 'data');
     if (typeof actor !== 'object' || actor === null)
@@ -79,6 +67,11 @@ function answeredOutcome(e, status, reading, cls, family, ours, tally, noteCapab
         return { ...base, kind: 'unconfirmed', cause: 'gone_after_retry', status };
     if (isSafetyStopLayer(e, reading))
         return { ...at, kind: 'not_applied', cause: 'refused', ...refusalOf(e, reading) };
+    if (code === ROUTE_NOT_FOUND) {
+        if (tally.retried)
+            return { ...base, kind: 'unconfirmed', cause: 'gone_after_retry', status };
+        return { ...at, kind: 'not_applied', cause: 'route_missing' };
+    }
     if (family === 'ask') {
         switch (code) {
             case ASK_DECIDED_CODE: {
@@ -131,7 +124,7 @@ function refusalOf(e, reading) {
     const r = classifyDeliveredDecisionRefusal(e, reading);
     return r !== undefined ? { refusal: r } : {};
 }
-async function sendApprovalFamily(respond, approvalId, answer, ctx) {
+async function sendApprovalFamily(respond, approvalId, answer, ctx, evidence) {
     const payload = answerPayloadFor(answer, 'respond', { approvalDecisionNoteCapable: ctx.noteCapable });
     if (payload === undefined)
         return { family: 'approval', attempts: ctx.tally.attempts, kind: 'not_sent', cause: 'not_an_answer' };
@@ -153,8 +146,11 @@ async function sendApprovalFamily(respond, approvalId, answer, ctx) {
         },
     });
     const retriedFact = ownReadingSlot(delivery, 'parkingRetried') === true ? { parkingRetried: true } : {};
-    if (delivery.kind === 'thrown')
+    if (delivery.kind === 'thrown') {
+        if (evidence !== undefined)
+            evidence.routeGone = respondRouteGoneOf(delivery);
         return { ...outcomeOfThrown(delivery.error, 'approval', ours, ctx.signal, ctx.tally, ctx.noteCapable), ...extras, ...retriedFact };
+    }
     const raw = delivery.raw;
     const facts = { ...extras, ...retriedFact, ...(ladder.dropped ? { attributionDropped: true } : {}), ...(ladder.renamed ? { attributionRenamed: true } : {}) };
     const base = { family: 'approval', attempts: ctx.tally.attempts, ...facts };
@@ -189,30 +185,40 @@ function bodyFacts(answer, payload, rememberUnsupported) {
     };
 }
 function answerGateCannotTake(out) {
-    return out.kind === 'not_applied' && (out.cause === 'gone' || out.cause === 'parking' || out.cause === 'lane_disabled');
+    return out.kind === 'not_applied' && (out.cause === 'gone' || out.cause === 'parking' || out.cause === 'lane_disabled' || out.cause === 'route_missing');
 }
-async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
+async function sendAskFamily(respondForFallback, decideAsk, req, ctx, family = 'ask') {
     const payload = answerPayloadFor(req.answer, 'respond', { approvalDecisionNoteCapable: ctx.noteCapable });
     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) {
-        const viaAnswerGate = await sendApprovalFamily(respondForFallback, req.approvalId, req.answer, ctx);
+        return { family, attempts: ctx.tally.attempts, kind: 'not_sent', cause: 'not_an_answer' };
+    let onAskDoor = ctx.door === 'ask_decision';
+    let fallbackRespond = onAskDoor ? undefined : respondForFallback;
+    if (!onAskDoor && req.answer.kind === 'allow' && req.answer.allowSession === true && respondForFallback !== undefined && req.approvalId !== undefined) {
+        const gate = { routeGone: false };
+        const viaAnswerGate = await sendApprovalFamily(respondForFallback, req.approvalId, req.answer, ctx, gate);
         if (!answerGateCannotTake(viaAnswerGate))
             return { ...viaAnswerGate, family: 'ask', allowSessionCarried: true };
-        hostLog('debug', `decisionSend: session-allow-fallback ask=${req.askId} cause=${String(viaAnswerGate.cause)} via=ask-decide-once`);
+        if (gate.routeGone) {
+            onAskDoor = true;
+            noteRespondDoorSwitch(ctx.doorReading, 'decisionSend', req.askId);
+            if (isAborted(ctx.signal))
+                return { ...viaAnswerGate, family: 'ask' };
+        }
+        else {
+            hostLog('debug', `decisionSend: session-allow-fallback ask=${req.askId} cause=${String(viaAnswerGate.cause)} via=ask-decide-once`);
+        }
         fallbackRespond = undefined;
     }
     const verdict = verdictOf(payload.decision) ?? 'deny';
     const attribution = req.answer.kind === 'deny' ? decisionAttributionKeyOf(ctx.decidedBy, readApprovalDenySettledBy(req.answer)) : {};
-    const body = {
-        decision: verdict,
-        idempotencyKey: hitlAskIdempotencyKey(req.askId, verdict),
-        ...(verdict === 'approve' && payload.updatedInput !== undefined ? { updatedInput: payload.updatedInput } : {}),
+    const carriesRemember = onAskDoor && payload.decision === 'allow_session';
+    const wireWord = payload.decision === 'allow_session' && !carriesRemember ? 'allow' : payload.decision;
+    const body = askDoorBodyOf(wireWord, {
+        ...(payload.updatedInput !== undefined ? { updatedInput: payload.updatedInput } : {}),
         ...(payload.note !== undefined ? { note: payload.note } : {}),
         ...attribution,
-    };
-    const extras = bodyFacts(req.answer, payload, true);
+    }, req.askId);
+    const extras = bodyFacts(req.answer, payload, !onAskDoor);
     const ladder = { lastCarried: false, dropped: false, renamed: false };
     let current = body;
     const parkingDelay = deliveryTiming().parkingDelayMs ?? PARKING_POLL_DELAY_MS;
@@ -222,13 +228,22 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
                 current = b;
                 return withTransportRetry((signal) => decideAsk(req.taskId, req.askId, b, signal !== undefined ? { signal } : undefined), ctx.signal, ctx.tally);
             }, ctx.signal, ladder, undefined, { kind: 'delivered', readingOf: (thrown) => deliveryReadingOf(thrown, ctx.tally) });
+            const askDoorBody = onAskDoor ? readAskDoorDecisionBody(raw, req.askId, payload.decision) : undefined;
+            if (askDoorBody?.kind === 'earlier') {
+                return { family, attempts: ctx.tally.attempts, ...extras, kind: 'settled_elsewhere', firstDecision: askDoorBody.firstDecision === 'allow' ? 'approve' : 'deny', contrary: true };
+            }
+            if (askDoorBody?.kind === 'other_ask')
+                return { family, attempts: ctx.tally.attempts, ...extras, kind: 'unconfirmed', cause: 'local_error' };
+            const ack = askDoorBody?.kind === 'receipt' ? askDoorBody.ack : undefined;
             return {
-                family: 'ask',
+                family,
                 attempts: ctx.tally.attempts,
                 ...extras,
                 ...(ladder.dropped ? { attributionDropped: true } : {}),
                 ...(ladder.renamed ? { attributionRenamed: true } : {}),
+                ...(carriesRemember ? { allowSessionCarried: true } : {}),
                 kind: 'applied',
+                ...(ack !== undefined ? { ack } : {}),
                 ...(ctx.noteCapable ? { noteAudit: readDecisionNoteAudit(raw) } : {}),
             };
         }
@@ -236,14 +251,14 @@ async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
             const settled = settledTransportReadingOf(e, ctx.signal, ctx.tally);
             const settledAnswer = ownReadingSlot(settled, 'answered');
             const code = settledAnswer !== undefined ? effectiveCodeOf(settledAnswer.code) : undefined;
-            const wait = Math.max(parkingDelay * (poll + 1), retryAfterMsOf(settledAnswer?.layer ?? e) ?? 0);
+            const wait = Math.max(parkingDelay * (poll + 1), retryAfterMsOf((settledAnswer?.layer ?? e)) ?? 0);
             const safetyStop = settledAnswer !== undefined && isSafetyStopLayer(settledAnswer.layer, settled);
             if (code === ASK_PARKING_RETRY && !safetyStop && poll < PARKING_POLL_MAX && !isAborted(ctx.signal) && wait <= PARKING_WAIT_CAP_MS && !budgetSpent(ctx.tally, wait)) {
                 await sleepFor(wait, ctx.signal);
                 if (!isAborted(ctx.signal))
                     continue;
             }
-            const out = outcomeOfThrown(e, 'ask', verdict, ctx.signal, ctx.tally, ctx.noteCapable, settled);
+            const out = { ...outcomeOfThrown(e, 'ask', verdict, ctx.signal, ctx.tally, ctx.noteCapable, settled), family };
             if (out.kind === 'not_applied' && out.cause === 'lane_disabled' && code === ASK_DECISION_LANE_DISABLED && req.approvalId !== undefined) {
                 if (fallbackRespond !== undefined && ctx.signal?.aborted !== true) {
                     const fb = await sendApprovalFamily(fallbackRespond, req.approvalId, req.answer, ctx);
@@ -459,7 +474,16 @@ export async function sendHitlDecision(request, deps) {
     const respond = verbOf(toolApprovals, 'respond');
     const decideAsk = verbOf(toolApprovals, 'decideAsk');
     const elicit = verbOf(hostField(client, 'elicitations'), 'respond');
-    if ((req.family === 'approval' && respond === undefined) || (req.family === 'ask' && decideAsk === undefined) || (req.family === 'elicitation' && elicit === undefined))
+    const doorReading = hostField(deps, 'approvalDecisionDoor');
+    const door = approvalDecisionDoorOf(doorReading);
+    if (door === 'ask_decision' && req.family === 'approval' && req.taskId === undefined)
+        return notSent('invalid_request');
+    const approvalVerbMissing = door === 'ask_decision' ? decideAsk === undefined : respond === undefined;
+    if (req.family === 'approval' && approvalVerbMissing)
+        return Object.freeze({ family, attempts: 0, kind: 'not_sent', cause: 'no_verb', door });
+    if (req.family === 'ask' && decideAsk === undefined)
+        return Object.freeze({ family, attempts: 0, kind: 'not_sent', cause: 'no_verb', door: 'ask_decision' });
+    if (req.family === 'elicitation' && elicit === undefined)
         return notSent('no_verb');
     if (req.family !== 'elicitation' && req.answer.kind !== 'allow' && req.answer.kind !== 'deny')
         return notSent('not_an_answer');
@@ -508,11 +532,27 @@ export async function sendHitlDecision(request, deps) {
         tally: newSendTally(),
         noteCapable: hostField(deps, 'approvalDecisionNoteCapable') === true,
         decidedBy: typeof decidedBy === 'object' && decidedBy !== null ? decidedBy : undefined,
+        door,
+        doorReading,
     };
     let out;
     try {
-        if (req.family === 'approval') {
-            out = await sendApprovalFamily(respond, req.approvalId, req.answer, ctx);
+        if (req.family === 'approval' && door === 'ask_decision') {
+            out = await sendAskFamily(undefined, decideAsk, { taskId: req.taskId, askId: req.approvalId, approvalId: req.approvalId, answer: req.answer }, ctx, 'approval');
+        }
+        else if (req.family === 'approval') {
+            const ev = { routeGone: false };
+            out = await sendApprovalFamily(respond, req.approvalId, req.answer, ctx, ev);
+            if (ev.routeGone) {
+                if (decideAsk === undefined || req.taskId === undefined) {
+                    hostLog('warn', ROUTE_MISSING_WIRING_HINT);
+                }
+                else {
+                    noteRespondDoorSwitch(ctx.doorReading, 'decisionSend', req.approvalId);
+                    if (!isAborted(signal))
+                        out = await sendAskFamily(undefined, decideAsk, { taskId: req.taskId, askId: req.approvalId, approvalId: req.approvalId, answer: req.answer }, { ...ctx, door: 'ask_decision' }, 'approval');
+                }
+            }
         }
         else if (req.family === 'ask') {
             out = await sendAskFamily(respond, decideAsk, { taskId: req.taskId, askId: req.askId, approvalId: req.approvalId, answer: req.answer }, ctx);
@@ -554,7 +594,7 @@ export async function sendHitlDecision(request, deps) {
     }
     const notApplied = out.kind !== 'applied' &&
         (out.pending === 'pending' ||
-            (out.kind === 'not_applied' && (out.cause === 'lane_disabled' || out.cause === 'idempotency_crossed' || (out.cause === 'refused' && out.refusal?.standing === 'refused-pending'))));
+            (out.kind === 'not_applied' && (out.cause === 'lane_disabled' || out.cause === 'route_missing' || out.cause === 'idempotency_crossed' || (out.cause === 'refused' && out.refusal?.standing === 'refused-pending'))));
     if (notApplied)
         op.notApplied = true;
     closeDecisionOp(op, 'package');
@@ -617,6 +657,15 @@ export function hitlDecisionOutcomeContent(outcome, lang) {
         }
         if (kind === 'unconfirmed' && readOwnDataValue(outcome, 'cause') === 'gone_after_retry')
             return unconfirmedDecisionContent('gone_after_retry', lang);
+        if (kind === 'not_applied' && readOwnDataValue(outcome, 'cause') === 'route_missing')
+            return renderMessage(msg('approval.routeMissing.line'), lang);
+        if (kind === 'not_sent' && readOwnDataValue(outcome, 'cause') === 'no_verb' && readOwnDataValue(outcome, 'family') === 'approval') {
+            const door = readOwnDataValue(outcome, 'door');
+            if (door === 'respond')
+                return renderMessage(msg('approval.decision.notSentOldServer', { version: ASK_DECISION_DOOR_SERVER_FROM }), lang);
+            if (door === 'ask_decision')
+                return renderMessage(msg('approval.decision.notSentNewerAddress'), lang);
+        }
         return undefined;
     }
     catch {

package/dist/hitl/frameRouter.d.ts

@@ -1,6 +1,6 @@
 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 RespondToolApprovalFn, type LegacyToolApprovalFrame, type ToolApprovalFrameLaneOpts } from './toolApprovalWire.js';
 import type { ApprovalDenyFacts, ApprovalResolution } from './approvalResolution.js';
 import type { GateLedger, GateDenyAttribution } from './gateLedger.js';
 import type { NoAllowCause } from './noAllowCause.js';
@@ -35,9 +35,9 @@ export interface AskGateWireDeps {
     onParkReattach?: (e: ParkReattachNotice) => void;
     onBreak?: (event: ReattachDrainingEvent) => void;
     approvalLane?: ToolApprovalFrameLaneOpts;
-    onToolApprovalOutcome?: (frame: ToolApprovalFrame, resolution: ApprovalResolution) => void | Promise<void>;
+    onToolApprovalOutcome?: (frame: LegacyToolApprovalFrame, resolution: ApprovalResolution) => void | Promise<void>;
     onDecideOperation?: DecideOperationObserver;
-    onReplayedApproval?: (frame: ToolApprovalFrame, disposition: ReplayedApprovalDisposition) => void | Promise<void>;
+    onReplayedApproval?: (frame: LegacyToolApprovalFrame, disposition: ReplayedApprovalDisposition) => void | Promise<void>;
     engineGeneration?: () => number;
 }
 type GateKind = 'ask' | 'fs';

package/dist/hitl/frameRouter.js

@@ -23,6 +23,7 @@ import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
 import { RUN_CANCELLED_CODE } from '../runCancelContext.js';
 import { durableDecideLegOf } from '../adapter/activeRunSelfHeal.js';
 import { subagentSourceSessionOf } from './subagentSource.js';
+import { approvalDecisionDoorOf } from './approvalDecisionDoor.js';
 export const HITL_REJECT_MESSAGE = REJECT_MESSAGE;
 export const HITL_POLICY_DENY_MESSAGE = 'Permission for this tool use was denied: it requires interactive approval, and permission prompts are ' +
     'not available in this session. The action was NOT performed. Do not claim it succeeded, and do not retry ' +
@@ -325,6 +326,10 @@ const TOOL_END_ARMS = [
 }
 async function routeToolApprovalFrame(ev, ctx) {
     const { led, deps } = ctx;
+    if (approvalDecisionDoorOf(guardedRead(() => readOwnDataValue(deps.approvalLane, 'approvalDecisionDoor'))) === 'ask_decision') {
+        hostLog('debug', `liveHitlAskWire: ${ev.type} frame ${String(guardedRead(() => readOwnDataValue(ev, 'approvalId')))} on a server that only has the ask decision door — old-family frame ignored (a replayed history row here; not a card, nothing sent)`);
+        return { kind: 'skip' };
+    }
     if (ev.type === 'tool_approval_complete') {
         if (settleEngineClosedApproval(ev, approvalCompleteParked(ev))) {
             const id = ev.approvalId;

package/dist/hitl/hitlBridge.d.ts

@@ -41,6 +41,7 @@ export interface PlanReviewOutcome {
     editedPlan?: string;
     reason?: string;
     permissionModeAfter?: PlanReviewModeAfter;
+    checkpointId?: string;
 }
 export declare const PLAN_REVIEW_MODE_AFTER_WORDS: readonly ["default", "acceptEdits"];
 export type PlanReviewModeAfter = (typeof PLAN_REVIEW_MODE_AFTER_WORDS)[number];

package/dist/hitl/hitlBridge.js

@@ -13,6 +13,7 @@ import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisio
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
 import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, unboundWayOutContent } from '../checkpointRowVerdict.js';
+import { DATA_FACE_LANGUAGE, msg, renderMessage } from '../i18n/translate.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -419,32 +420,44 @@ export class HitlBridge {
         return this.decideRaw(pending.sessionId, decision, opts);
     }
     async reviewPlan(outcome, opts) {
+        const decisionRaw = outcome.decision;
+        const decision = decisionRaw === 'approve' || decisionRaw === 'edit' || decisionRaw === 'reject' ? decisionRaw : undefined;
+        if (decision === undefined) {
+            throw new HitlSafetyError('plan-review decision must be "approve", "edit" or "reject"', 'bad_plan_edit');
+        }
         const kind = this.active?.gate.kind;
         if (kind && kind !== 'plan_review' && kind !== 'needs_review') {
             throw new HitlSafetyError(`cannot plan-review a "${kind}" gate — a plan decision must never resolve a tool approval`, 'wrong_gate');
         }
-        if (outcome.decision === 'edit') {
+        if (decision === 'edit') {
             if (!outcome.editedPlan || outcome.editedPlan.length === 0) {
                 throw new HitlSafetyError('plan-review "edit" requires a non-empty editedPlan', 'bad_plan_edit');
             }
         }
         else if (outcome.editedPlan !== undefined) {
-            throw new HitlSafetyError(`plan-review "${outcome.decision}" must NOT carry editedPlan`, 'bad_plan_edit');
+            throw new HitlSafetyError(`plan-review "${decision}" must NOT carry editedPlan`, 'bad_plan_edit');
         }
         const modeAfter = outcome.permissionModeAfter;
         if (modeAfter !== undefined && !isPlanReviewModeAfter(modeAfter)) {
             throw new HitlSafetyError('plan-review permissionModeAfter must be "default" or "acceptEdits"', 'bad_plan_mode');
         }
-        const req = { decision: outcome.decision };
+        const gateRaw = outcome.checkpointId;
+        const gate = typeof gateRaw === 'string' && gateRaw !== '' ? gateRaw : undefined;
+        if (gate === undefined && (decision === 'approve' || decision === 'edit')) {
+            throw new HitlSafetyError(renderMessage(msg('approval.planReview.bridge.gateIdMissing'), DATA_FACE_LANGUAGE), 'wrong_gate');
+        }
+        const req = { decision };
         if (modeAfter !== undefined && isPlanReviewModeAfter(modeAfter))
             req.permissionModeAfter = modeAfter;
-        if (outcome.decision === 'edit' && outcome.editedPlan !== undefined)
+        if (decision === 'edit' && outcome.editedPlan !== undefined)
             req.editedPlan = outcome.editedPlan;
         if (outcome.reason !== undefined) {
             const r = denyReasonForWire(outcome.reason, `plan-review ${this.taskId}`);
             if (r !== undefined)
                 req.reason = r;
         }
+        if (gate !== undefined)
+            req.checkpointId = gate;
         return this.client.assistant.planReview(this.taskId, req, opts);
     }
     async resumeResourceLimit(opts) {

package/dist/hitl/hitlHostSurface.d.ts

@@ -34,8 +34,9 @@ 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;
 export declare function surfaceApprovalParking(retryAfterMs?: number): void;
-export declare const COMPACT_NOT_RUNNING_WARN_TEXT = "engine run finished before compaction was applied; nothing was compacted";
-export declare function surfaceCompactNotRunning(sessionKey?: string): void;
+export declare const COMPACT_NOT_RUNNING_WARN_TEXT: string;
+export declare const COMPACT_WILL_RETRY_WARN_TEXT: string;
+export declare function surfaceCompactNotRunning(sessionKey: string, phase: 'will_retry' | 'final'): void;
 export declare const REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT: string;
 export declare function surfaceReplayedApprovalListUnreadable(): void;
 export declare const EDIT_REFUSED_ON_BLIND_ASK_WARN_TEXT: string;

package/dist/hitl/hitlHostSurface.js

@@ -3,6 +3,7 @@ import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { editedApprovalRefusedLine } from './editedApprovalAcceptance.js';
+import { msg, renderMessage } from '../i18n/translate.js';
 import { decisionRefusalSaysAskGone } from './decisionRefusal.js';
 import { deliveryTiming, RETRY_BUDGET_MS } from './approvalDelivery.js';
 const hostSurfaceByKey = createSessionSlot();
@@ -97,11 +98,12 @@ export function approvalParkingNoticeText(retryAfterMs) {
 export function surfaceApprovalParking(retryAfterMs) {
     surfaceSelfClearingWarn(APPROVAL_PARKING_KEY, approvalParkingNoticeText(retryAfterMs), APPROVAL_PARKING_TIMEOUT_MS);
 }
-export const COMPACT_NOT_RUNNING_WARN_TEXT = 'engine run finished before compaction was applied; nothing was compacted';
+export const COMPACT_NOT_RUNNING_WARN_TEXT = renderMessage(msg('session.compaction.notRunning.final'));
+export const COMPACT_WILL_RETRY_WARN_TEXT = renderMessage(msg('session.compaction.notRunning.willRetry'));
 const COMPACT_NOT_RUNNING_KEY = 'engine-compact-not-running';
 const COMPACT_NOT_RUNNING_TIMEOUT_MS = 10_000;
-export function surfaceCompactNotRunning(sessionKey = DEFAULT_SESSION_KEY) {
-    surfaceSelfClearingWarn(COMPACT_NOT_RUNNING_KEY, COMPACT_NOT_RUNNING_WARN_TEXT, COMPACT_NOT_RUNNING_TIMEOUT_MS, sessionKey);
+export function surfaceCompactNotRunning(sessionKey, phase) {
+    surfaceSelfClearingWarn(COMPACT_NOT_RUNNING_KEY, phase === 'will_retry' ? COMPACT_WILL_RETRY_WARN_TEXT : COMPACT_NOT_RUNNING_WARN_TEXT, COMPACT_NOT_RUNNING_TIMEOUT_MS, sessionKey);
 }
 export const REPLAYED_APPROVAL_LIST_UNREADABLE_WARN_TEXT = "Could not read the pending-approval list, so an approval request read back from this run's event log was not raised as a question, " +
     'and no decision was sent for it.';