@sema-agent/client-core 0.109.0 → 0.111.0

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';
@@ -89,6 +89,8 @@ function policyDenyHeadFor(cause) {
             return renderMessage(msg('approval.policyDeny.denyRule', { tail }));
         case 'engine_floor':
             return renderMessage(msg('approval.policyDeny.engineFloor', { tail }));
+        case 'hook':
+            return renderMessage(msg('approval.policyDeny.hook'));
         case 'no_approval_ui':
         case undefined:
             return HITL_POLICY_DENY_MESSAGE;
@@ -117,20 +119,6 @@ function denyStampedEnd(ev, attribution) {
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
-const bridgeRunHandleFallbacks = new WeakMap();
-export function setBridgeRunHandleFallback(deps, read) {
-    bridgeRunHandleFallbacks.set(deps, read);
-}
-export function bridgeRunHandleFallbackOf(deps) {
-    try {
-        const read = bridgeRunHandleFallbacks.get(deps);
-        const v = read?.();
-        return typeof v === 'string' && v !== '' ? v : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function isAskToolLoose(name) {
     return typeof name === 'string' && name.replace(/[\s_-]+/g, '').toLowerCase() === 'askuserquestion';
 }
@@ -349,7 +337,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 +345,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) {
@@ -373,7 +359,12 @@ async function routeToolApprovalFrame(ev, ctx) {
     const gatedCallId = fromSubagent ? undefined : frameCallId ?? led.lastPendingFsCall();
     const argsCallId = frameCallId === undefined ? gatedCallId : typeof ev.toolName === 'string' && toolNameIsFsWrite(ev.toolName) ? frameCallId : undefined;
     const runTaskId = ctx.taskId.current;
-    const launched = surfaceToolApprovalFrameAndRespond(ev, deps.respondToolApproval, argsOfGatedStart(led, argsCallId), ctx.signal, deps.approvalLane, typeof runTaskId === 'string' && runTaskId !== '' ? { taskId: runTaskId } : undefined);
+    const streamGeneration = ctx.streamGeneration;
+    const runFacts = {
+        ...(typeof runTaskId === 'string' && runTaskId !== '' ? { taskId: runTaskId } : {}),
+        ...(streamGeneration !== undefined ? { sourceGeneration: streamGeneration } : {}),
+    };
+    const launched = surfaceToolApprovalFrameAndRespond(ev, deps.respondToolApproval, argsOfGatedStart(led, argsCallId), ctx.signal, deps.approvalLane, Object.keys(runFacts).length > 0 ? runFacts : undefined);
     const hold = liveCardHoldOf(liveFrameCallKey(ev.approvalId));
     const handled = launched.then((outcome) => settleLiveCardOutcome(ev, outcome, ctx, fromSubagent, gatedCallId), (e) => {
         hostLog('debug', `liveHitlAskWire: tool_approval card for ${ev.approvalId} failed: ${String(e).slice(0, 160)}`);
@@ -416,7 +407,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 +502,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/gateIdentity.d.ts

@@ -1,9 +1,14 @@
 export declare const PLAN_REVIEW_QUESTION_ID_PREFIX = "plan-review:";
 export declare const REOPEN_ID_TAIL = "#reopen-";
+export declare const SCREEN_CARD_ORIGINS: readonly ["live-approval", "park-approval", "park-question", "plan-review", "host-reopen-question", "host-choice", "local-permission"];
+export type ScreenCardOrigin = (typeof SCREEN_CARD_ORIGINS)[number];
 export declare function approvalCallKey(gatedCallId: string | undefined, taskId: string): string;
 export declare function askGateQuestionId(callKey: string): string;
 export declare function planReviewQuestionId(taskId: string): string;
 export declare function freshPlanReviewQuestionId(taskId: string, suffix: string): string;
+export declare function hostReopenQuestionId(rowTaskId: string, suffix: string): string;
+export declare function hostRunChoiceQuestionId(taskId: string, suffix: string): string;
+export declare function questionCardOriginOf(questionId: {} | null | undefined): Extract<ScreenCardOrigin, 'park-question' | 'plan-review' | 'host-reopen-question' | 'host-choice'> | undefined;
 export declare function liveFrameCallKey(approvalId: string): string;
 export declare function taskIdFromPlanReviewQuestionId(questionId: string): string | undefined;
 export declare function armedKeyFromQuestionId(questionId: string): string;

package/dist/hitl/gateIdentity.js

@@ -2,6 +2,9 @@ const HITL_ASK_QUESTION_ID_PREFIX = 'hitl-ask:';
 export const PLAN_REVIEW_QUESTION_ID_PREFIX = 'plan-review:';
 const HITL_FRAME_CALL_KEY_PREFIX = 'hitl-frame:';
 export const REOPEN_ID_TAIL = '#reopen-';
+const HOST_REOPEN_QUESTION_ID_PREFIX = 'ask-park:';
+const HOST_RUN_CHOICE_QUESTION_ID_PREFIX = 'active-run:';
+export const SCREEN_CARD_ORIGINS = Object.freeze(['live-approval', 'park-approval', 'park-question', 'plan-review', 'host-reopen-question', 'host-choice', 'local-permission']);
 export function approvalCallKey(gatedCallId, taskId) {
     return gatedCallId ?? taskId;
 }
@@ -14,6 +17,26 @@ export function planReviewQuestionId(taskId) {
 export function freshPlanReviewQuestionId(taskId, suffix) {
     return `${planReviewQuestionId(taskId)}${REOPEN_ID_TAIL}${suffix}`;
 }
+export function hostReopenQuestionId(rowTaskId, suffix) {
+    return `${HOST_REOPEN_QUESTION_ID_PREFIX}${rowTaskId}${REOPEN_ID_TAIL}${suffix}`;
+}
+export function hostRunChoiceQuestionId(taskId, suffix) {
+    return `${HOST_RUN_CHOICE_QUESTION_ID_PREFIX}${taskId}${REOPEN_ID_TAIL}${suffix}`;
+}
+export function questionCardOriginOf(questionId) {
+    if (typeof questionId !== 'string')
+        return undefined;
+    const has = (prefix) => questionId.startsWith(prefix) && questionId.length > prefix.length;
+    if (has(HITL_ASK_QUESTION_ID_PREFIX))
+        return 'park-question';
+    if (has(PLAN_REVIEW_QUESTION_ID_PREFIX))
+        return 'plan-review';
+    if (has(HOST_REOPEN_QUESTION_ID_PREFIX))
+        return 'host-reopen-question';
+    if (has(HOST_RUN_CHOICE_QUESTION_ID_PREFIX))
+        return 'host-choice';
+    return undefined;
+}
 export function liveFrameCallKey(approvalId) {
     return `${HITL_FRAME_CALL_KEY_PREFIX}${approvalId}`;
 }

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

@@ -138,6 +138,12 @@ export type FindPendingOutcome = {
         readonly kind: 'ok';
     }>;
 };
+export interface PendingRowCallIdentity {
+    readonly taskId?: string | null;
+    readonly toolCallId?: string | null;
+    readonly boundCallId?: string | null;
+}
+export declare function pendingRowAnswersCall(row: PendingRowCallIdentity, taskId: string, callId: string): boolean;
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;
 }, callId?: string, identityAccepts?: (row: PendingCheckpoint) => boolean): Promise<FindPendingOutcome>;
@@ -160,6 +166,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

@@ -8,6 +8,7 @@ import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
 import { PROTOCOL_ERROR_NAME, isSlotCarrier, protocolErrorNameReading, readBlockedBy, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_INVALID_OUTCOME, RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { suspendedReopenOf } from './suspendedReopen.js';
+import { decisionConflictOf } from './decisionConflict.js';
 import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisionLedger.js';
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
@@ -259,6 +260,9 @@ function notifyDecideObserver(observer, ev) {
     invokeHostCallbackIsolated(`hitlBridge: onDecideOperation(${ev.phase})`, () => observer(ev));
 }
 const ANY_TOOL_FAMILY = () => true;
+export function pendingRowAnswersCall(row, taskId, callId) {
+    return row.taskId === taskId && (row.boundCallId === callId || row.toolCallId === callId);
+}
 export async function findPendingForTask(client, taskId, matches, opts, callId, identityAccepts = (r) => matches(typeof r.toolName === 'string' ? r.toolName : undefined)) {
     let rows;
     try {
@@ -275,10 +279,10 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
     });
     const decidable = readings.filter((x) => x.foreign === null).map((x) => x.r);
     const identityRow = callId !== undefined
-        ? decidable.find((r) => r.taskId === taskId && (r.boundCallId === callId || r.toolCallId === callId))
+        ? decidable.find((r) => pendingRowAnswersCall(r, taskId, callId))
         : undefined;
     const identityForeign = callId !== undefined && identityRow === undefined
-        ? readings.find((x) => x.r.taskId === taskId && (x.r.boundCallId === callId || x.r.toolCallId === callId) && x.foreign !== null)
+        ? readings.find((x) => pendingRowAnswersCall(x.r, taskId, callId) && x.foreign !== null)
         : undefined;
     if (identityForeign !== undefined) {
         const identityBar = identityForeign.foreign === QUEUE_ROW_FAMILY_UNREADABLE_GATE ? checkpointRowBarOf(identityForeign.r) : undefined;
@@ -385,6 +389,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 +603,13 @@ 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);
-    if (family)
-        return 'mismatch';
-    if (nameReading.state === 'sdk-instance' && code.state !== 'code')
-        return 'unreadable';
+    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) {
+        const captured = code.state === 'code' ? { state: 'read', wire: code.code } : code.state === 'absent' ? { state: 'read' } : { state: 'unreadable' };
+        return decisionConflictOf(e, captured, nameReading) === 'row_integrity' ? 'not' : 'mismatch';
+    }
     if (code.state === 'unreadable')
         return 'unreadable';
     return 'not';

package/dist/hitl/hitlHostSurface.d.ts

@@ -22,12 +22,14 @@ export declare function hitlHostSurfaceMissesFor(sessionKey: string): number;
 export declare function hitlHostSurfaceFor(sessionKey: string): HitlHostSurface | null;
 export declare function _resetHitlHostSurfaceForTest(): void;
 export declare function surfaceForCurrentSession(): HitlHostSurface | null;
-export declare const CANCEL_DENY_BUDGET_MS = 2000;
+export declare const CANCEL_DENY_BUDGET_MS = 8000;
+export declare function interruptDenyLifetime(): AbortSignal;
 export declare const INTERRUPT_DENY_REASON = "Interrupted by user";
 export declare const CANCEL_DENY_WARN_TEXT = "could not cancel the pending question \u2014 the session may stay locked; the run may need engine-side recovery";
 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,7 +2,9 @@ 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';
+import { deliveryTiming, RETRY_BUDGET_MS } from './approvalDelivery.js';
 const hostSurfaceByKey = createSessionSlot();
 const hostSurfaceMissesByKey = new Map();
 export function installHitlHostSurface(surface) {
@@ -38,7 +40,10 @@ function surfaceForSession(sessionKey) {
     }
     return hostSurface;
 }
-export const CANCEL_DENY_BUDGET_MS = 2000;
+export const CANCEL_DENY_BUDGET_MS = RETRY_BUDGET_MS;
+export function interruptDenyLifetime() {
+    return AbortSignal.timeout(Math.max(1, deliveryTiming().budgetMs));
+}
 export const INTERRUPT_DENY_REASON = 'Interrupted by user';
 export const CANCEL_DENY_WARN_TEXT = 'could not cancel the pending question — the session may stay locked; the run may need engine-side recovery';
 const CANCEL_DENY_WARN_KEY = 'hitl-cancel-deny-warn';
@@ -73,6 +78,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 +110,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);
@@ -135,8 +144,9 @@ export function surfaceRuleArmRejected(why) {
 }
 export function observeCancelByDeny(settle, taskId) {
     let timer;
+    const budgetMs = deliveryTiming().budgetMs;
     const budget = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`cancel-by-deny did not settle within ${CANCEL_DENY_BUDGET_MS}ms`)), CANCEL_DENY_BUDGET_MS);
+        timer = setTimeout(() => reject(new Error(`cancel-by-deny did not settle within ${budgetMs}ms`)), budgetMs);
         unrefTimer(timer);
     });
     void Promise.race([settle, budget])

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;
+}

package/dist/hitl/localAllowRedemption.d.ts

@@ -0,0 +1,67 @@
+import type { EngineCapState } from '../engineCapsCache.js';
+import type { HostSettingsLayer, WorkspaceTrustState } from '../hostSettingsSource.js';
+import { type LocalAllowRuleDeps } from './localAllowRule.js';
+import { type ListAllPersistedRulesOutcome, type RulesFacade } from './persistedRulesWire.js';
+export declare const LOCAL_ALLOW_NOT_REDEEMABLE_REASONS: readonly ["managed_only", "tighten_only", "no_scope_root", "no_consent", "road_closed"];
+export type LocalAllowNotRedeemableReason = (typeof LOCAL_ALLOW_NOT_REDEEMABLE_REASONS)[number];
+export declare const LOCAL_ALLOW_UNKNOWN_CAUSES: readonly ["input_unreadable", "policy_unreadable", "consent_unreadable", "road_unknown"];
+export type LocalAllowUnknownCause = (typeof LOCAL_ALLOW_UNKNOWN_CAUSES)[number];
+export type LocalAllowRedeemability = {
+    readonly kind: 'redeemable';
+    readonly via: 'layer' | 'consent';
+} | {
+    readonly kind: 'not_redeemable';
+    readonly reason: LocalAllowNotRedeemableReason;
+} | {
+    readonly kind: 'unknown';
+    readonly cause: LocalAllowUnknownCause;
+};
+export interface LocalAllowOfferedFacts {
+    readonly managedRulesOnly: boolean | 'unreadable';
+    readonly scopeRoot: string | undefined;
+    readonly road: EngineCapState;
+}
+export type LocalAllowRedeemabilityInput = ({
+    readonly subject: 'offered';
+} & LocalAllowOfferedFacts) | {
+    readonly subject: 'declared';
+    readonly source: HostSettingsLayer;
+    readonly workspace: WorkspaceTrustState | 'unreadable';
+    readonly managedRulesOnly: boolean | 'unreadable';
+    readonly rule: string;
+    readonly scopeRoot: string | undefined;
+    readonly store: ListAllPersistedRulesOutcome;
+};
+export declare function localAllowRedeemability(input: LocalAllowRedeemabilityInput): LocalAllowRedeemability;
+export declare const LOCAL_ALLOW_REDEMPTION_REFUSALS: readonly ["managed_only", "no_scope_root", "rule_shape", "request_refused", "preview_mismatch", "engine_refused", "ticket_dead"];
+export type LocalAllowRedemptionRefusal = (typeof LOCAL_ALLOW_REDEMPTION_REFUSALS)[number];
+export declare const LOCAL_ALLOW_REDEMPTION_UNAVAILABLE_CAUSES: readonly ["road_closed", "road_unknown", "policy_unreadable", "input_unreadable", "prepare_failed"];
+export type LocalAllowRedemptionUnavailableCause = (typeof LOCAL_ALLOW_REDEMPTION_UNAVAILABLE_CAUSES)[number];
+export declare const LOCAL_ALLOW_REDEMPTION_UNKNOWN_CAUSES: readonly ["redeem_unsettled", "receipt_unreadable"];
+export type LocalAllowRedemptionUnknownCause = (typeof LOCAL_ALLOW_REDEMPTION_UNKNOWN_CAUSES)[number];
+export type LocalAllowRedemptionReceipt = {
+    readonly kind: 'applied';
+    readonly outcome: 'persisted' | 'already_live';
+    readonly rule: string;
+    readonly scope: string;
+} | {
+    readonly kind: 'refused';
+    readonly reason: LocalAllowRedemptionRefusal;
+    readonly detail?: string;
+} | {
+    readonly kind: 'unavailable';
+    readonly cause: LocalAllowRedemptionUnavailableCause;
+} | {
+    readonly kind: 'unknown';
+    readonly cause: LocalAllowRedemptionUnknownCause;
+};
+export type LocalAllowRedemptionFacade = Pick<RulesFacade, 'ccImportPrepare' | 'ccImportRedeem'>;
+export interface ReadOnlyRuleOfferRedemption extends LocalAllowOfferedFacts {
+    readonly rule: string;
+    readonly expectedToolName?: string;
+    readonly settingsPath: string;
+    readonly deps: LocalAllowRuleDeps;
+}
+export declare function redeemReadOnlyRuleOffer(facade: LocalAllowRedemptionFacade, input: ReadOnlyRuleOfferRedemption, opts?: {
+    readonly signal?: AbortSignal;
+}): Promise<LocalAllowRedemptionReceipt>;