@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/hitl/frameRouter.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';
 }
@@ -371,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)}`);

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/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>;

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;
@@ -602,8 +606,10 @@ function bindingMismatchReading(e) {
     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 (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,7 +22,8 @@ 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";

package/dist/hitl/hitlHostSurface.js

@@ -4,6 +4,7 @@ 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) {
@@ -39,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';
@@ -140,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/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>;

package/dist/hitl/localAllowRedemption.js

@@ -0,0 +1,256 @@
+import { displayUntrusted } from '../displayUntrusted.js';
+import { readOwnDataValue } from '../ownKey.js';
+import { layerAdmissionWord } from '../settingsLayerAdmission.js';
+import { parseLocalAllowRule } from './localAllowRule.js';
+import { classifyRulesFailure, classifySkippedReason, readCcImportRedeemCounts, } from './persistedRulesWire.js';
+export const LOCAL_ALLOW_NOT_REDEEMABLE_REASONS = Object.freeze(['managed_only', 'tighten_only', 'no_scope_root', 'no_consent', 'road_closed']);
+export const LOCAL_ALLOW_UNKNOWN_CAUSES = Object.freeze(['input_unreadable', 'policy_unreadable', 'consent_unreadable', 'road_unknown']);
+function verdict(v) {
+    return Object.freeze({ ...v });
+}
+const notRedeemable = (reason) => verdict({ kind: 'not_redeemable', reason });
+const unknownBecause = (cause) => verdict({ kind: 'unknown', cause });
+const PROJECT_SCOPE_PREFIX = 'project:';
+const ALLOW_BEHAVIOR = 'allow';
+const MANAGED_LAYER = 'policySettings';
+const DETAIL_SHOWN_MAX = 400;
+function policyStep(v) {
+    if (v === true)
+        return notRedeemable('managed_only');
+    if (v === false)
+        return undefined;
+    return unknownBecause('policy_unreadable');
+}
+function scopeRootOf(v) {
+    return typeof v === 'string' && v !== '' ? v : undefined;
+}
+function storeRowConsents(row, rule, scopeRoot) {
+    if (typeof row !== 'object' || row === null)
+        return false;
+    const behavior = readOwnDataValue(row, 'behavior');
+    const text = readOwnDataValue(row, 'rule');
+    const scope = readOwnDataValue(row, 'scope');
+    return behavior === ALLOW_BEHAVIOR && text === rule && (scope === 'global' || scope === PROJECT_SCOPE_PREFIX + scopeRoot);
+}
+function consentRecorded(store, rule, scopeRoot) {
+    if (typeof store !== 'object' || store === null)
+        return undefined;
+    const ok = readOwnDataValue(store, 'ok');
+    if (ok !== true)
+        return undefined;
+    const rows = readOwnDataValue(store, 'rules');
+    if (!Array.isArray(rows))
+        return undefined;
+    for (let i = 0; i < rows.length; i++) {
+        if (storeRowConsents(readOwnDataValue(rows, String(i)), rule, scopeRoot))
+            return true;
+    }
+    return false;
+}
+function roadStep(road) {
+    if (road === 'true')
+        return verdict({ kind: 'redeemable', via: 'consent' });
+    if (road === 'false' || road === 'absent')
+        return notRedeemable('road_closed');
+    return unknownBecause('road_unknown');
+}
+export function localAllowRedeemability(input) {
+    try {
+        if (typeof input !== 'object' || input === null)
+            return unknownBecause('input_unreadable');
+        const subject = readOwnDataValue(input, 'subject');
+        if (subject !== 'offered' && subject !== 'declared')
+            return unknownBecause('input_unreadable');
+        const source = readOwnDataValue(input, 'source');
+        if (!(subject === 'declared' && source === MANAGED_LAYER)) {
+            const policy = policyStep(readOwnDataValue(input, 'managedRulesOnly'));
+            if (policy !== undefined)
+                return policy;
+        }
+        const scopeRoot = scopeRootOf(readOwnDataValue(input, 'scopeRoot'));
+        if (subject === 'offered') {
+            if (scopeRoot === undefined)
+                return notRedeemable('no_scope_root');
+            return roadStep(readOwnDataValue(input, 'road'));
+        }
+        const workspace = readOwnDataValue(input, 'workspace');
+        let word;
+        try {
+            word = layerAdmissionWord(source, workspace, 'permissions', ALLOW_BEHAVIOR);
+        }
+        catch {
+            return unknownBecause('input_unreadable');
+        }
+        if (word === 'admitted')
+            return verdict({ kind: 'redeemable', via: 'layer' });
+        if (word === 'tighten_only')
+            return notRedeemable('tighten_only');
+        if (scopeRoot === undefined)
+            return notRedeemable('no_scope_root');
+        const rule = readOwnDataValue(input, 'rule');
+        if (typeof rule !== 'string' || rule === '')
+            return unknownBecause('input_unreadable');
+        const consent = consentRecorded(readOwnDataValue(input, 'store'), rule, scopeRoot);
+        if (consent === undefined)
+            return unknownBecause('consent_unreadable');
+        return consent ? verdict({ kind: 'redeemable', via: 'consent' }) : notRedeemable('no_consent');
+    }
+    catch {
+        return unknownBecause('input_unreadable');
+    }
+}
+export const LOCAL_ALLOW_REDEMPTION_REFUSALS = Object.freeze([
+    'managed_only',
+    'no_scope_root',
+    'rule_shape',
+    'request_refused',
+    'preview_mismatch',
+    'engine_refused',
+    'ticket_dead',
+]);
+export const LOCAL_ALLOW_REDEMPTION_UNAVAILABLE_CAUSES = Object.freeze(['road_closed', 'road_unknown', 'policy_unreadable', 'input_unreadable', 'prepare_failed']);
+export const LOCAL_ALLOW_REDEMPTION_UNKNOWN_CAUSES = Object.freeze(['redeem_unsettled', 'receipt_unreadable']);
+function singleRuleLayerContent(canonical) {
+    return JSON.stringify({ permissions: { allow: [canonical] } });
+}
+function receipt(r) {
+    return Object.freeze({ ...r });
+}
+function detailOf(text) {
+    if (typeof text !== 'string')
+        return {};
+    const shown = displayUntrusted(text, { max: DETAIL_SHOWN_MAX });
+    return shown.trim() !== '' ? { detail: shown } : {};
+}
+const JUDGED_RECEIPT = {
+    managed_only: { kind: 'refused', reason: 'managed_only' },
+    no_scope_root: { kind: 'refused', reason: 'no_scope_root' },
+    road_closed: { kind: 'unavailable', cause: 'road_closed' },
+    road_unknown: { kind: 'unavailable', cause: 'road_unknown' },
+    policy_unreadable: { kind: 'unavailable', cause: 'policy_unreadable' },
+    input_unreadable: { kind: 'unavailable', cause: 'input_unreadable' },
+    tighten_only: { kind: 'unavailable', cause: 'input_unreadable' },
+    no_consent: { kind: 'unavailable', cause: 'input_unreadable' },
+    consent_unreadable: { kind: 'unavailable', cause: 'input_unreadable' },
+};
+function previewSingle(prep, scopeRoot) {
+    const preview = typeof prep === 'object' && prep !== null ? readOwnDataValue(prep, 'preview') : undefined;
+    if (typeof preview !== 'object' || preview === null)
+        return { mismatch: true };
+    const skipped = readOwnDataValue(preview, 'skipped');
+    if (Array.isArray(skipped) && skipped.length > 0) {
+        const first = readOwnDataValue(skipped, '0');
+        const reason = typeof first === 'object' && first !== null ? readOwnDataValue(first, 'reason') : undefined;
+        return { mismatch: true, skipped: typeof reason === 'string' ? classifySkippedReason(reason).text : '' };
+    }
+    if (!Array.isArray(skipped))
+        return { mismatch: true };
+    const candidates = readOwnDataValue(preview, 'candidates');
+    if (!Array.isArray(candidates) || candidates.length !== 1)
+        return { mismatch: true };
+    const c = readOwnDataValue(candidates, '0');
+    if (typeof c !== 'object' || c === null)
+        return { mismatch: true };
+    const behavior = readOwnDataValue(c, 'behavior');
+    const rule = readOwnDataValue(c, 'rule');
+    const scope = readOwnDataValue(c, 'scope');
+    const kind = typeof scope === 'object' && scope !== null ? readOwnDataValue(scope, 'kind') : undefined;
+    const root = typeof scope === 'object' && scope !== null ? readOwnDataValue(scope, 'root') : undefined;
+    if (behavior !== ALLOW_BEHAVIOR || typeof rule !== 'string' || kind !== 'project' || root !== scopeRoot)
+        return { mismatch: true };
+    return { rule };
+}
+export async function redeemReadOnlyRuleOffer(facade, input, opts) {
+    let canonical;
+    let offered;
+    let scopeRoot;
+    let settingsPath;
+    try {
+        if (typeof input !== 'object' || input === null)
+            return receipt({ kind: 'unavailable', cause: 'input_unreadable' });
+        const judged = localAllowRedeemability({
+            subject: 'offered',
+            managedRulesOnly: readOwnDataValue(input, 'managedRulesOnly'),
+            scopeRoot: readOwnDataValue(input, 'scopeRoot'),
+            road: readOwnDataValue(input, 'road'),
+        });
+        if (judged.kind !== 'redeemable')
+            return receipt(JUDGED_RECEIPT[judged.kind === 'not_redeemable' ? judged.reason : judged.cause]);
+        scopeRoot = readOwnDataValue(input, 'scopeRoot');
+        const path = readOwnDataValue(input, 'settingsPath');
+        if (typeof path !== 'string' || path === '')
+            return receipt({ kind: 'unavailable', cause: 'input_unreadable' });
+        settingsPath = path;
+        const rule = readOwnDataValue(input, 'rule');
+        const expected = readOwnDataValue(input, 'expectedToolName');
+        const deps = readOwnDataValue(input, 'deps');
+        if (typeof rule !== 'string' || deps === undefined || (expected !== undefined && typeof expected !== 'string'))
+            return receipt({ kind: 'unavailable', cause: 'input_unreadable' });
+        const parsed = parseLocalAllowRule(rule, expected, deps);
+        if (!parsed.ok)
+            return receipt({ kind: 'refused', reason: 'rule_shape', ...detailOf(parsed.error) });
+        canonical = parsed.canonical;
+        offered = rule;
+    }
+    catch {
+        return receipt({ kind: 'unavailable', cause: 'input_unreadable' });
+    }
+    const signal = opts?.signal;
+    let prep;
+    try {
+        prep = await facade.ccImportPrepare([{ layer: 'localSettings', path: settingsPath, root: scopeRoot, content: singleRuleLayerContent(canonical) }], signal !== undefined ? { signal } : undefined);
+    }
+    catch (e) {
+        const f = classifyRulesFailure(e);
+        if (f.kind === 'lane-unavailable' || f.kind === 'route-missing')
+            return receipt({ kind: 'unavailable', cause: 'road_closed' });
+        if (f.kind === 'body-shape' || f.kind === 'field-refused' || f.kind === 'too-many-candidates' || f.kind === 'forbidden' || f.kind === 'operators-unconfigured') {
+            return receipt({ kind: 'refused', reason: 'request_refused' });
+        }
+        return receipt({ kind: 'unavailable', cause: 'prepare_failed' });
+    }
+    let ticket;
+    let storedRule;
+    try {
+        const single = previewSingle(prep, scopeRoot);
+        if ('mismatch' in single) {
+            return receipt(single.skipped !== undefined ? { kind: 'refused', reason: 'engine_refused', ...detailOf(single.skipped) } : { kind: 'refused', reason: 'preview_mismatch' });
+        }
+        if (single.rule !== canonical && single.rule !== offered)
+            return receipt({ kind: 'refused', reason: 'preview_mismatch' });
+        storedRule = single.rule;
+        const t = readOwnDataValue(prep, 'ticket');
+        if (typeof t !== 'string' || t === '')
+            return receipt({ kind: 'refused', reason: 'preview_mismatch' });
+        ticket = t;
+    }
+    catch {
+        return receipt({ kind: 'refused', reason: 'preview_mismatch' });
+    }
+    let body;
+    try {
+        body = await facade.ccImportRedeem(ticket, signal !== undefined ? { signal } : undefined);
+    }
+    catch (e) {
+        const f = classifyRulesFailure(e);
+        if (f.kind === 'ticket-dead')
+            return receipt({ kind: 'refused', reason: 'ticket_dead' });
+        if (f.kind === 'lane-unavailable')
+            return receipt({ kind: 'unavailable', cause: 'road_closed' });
+        return receipt({ kind: 'unknown', cause: 'redeem_unsettled' });
+    }
+    const counts = readCcImportRedeemCounts(body);
+    if (counts === null)
+        return receipt({ kind: 'unknown', cause: 'receipt_unreadable' });
+    const refusedRow = counts.refused?.[0];
+    if (refusedRow !== undefined)
+        return receipt({ kind: 'refused', reason: 'engine_refused', ...detailOf(refusedRow.detail) });
+    if (counts.indeterminate.length > 0)
+        return receipt({ kind: 'unknown', cause: 'redeem_unsettled' });
+    const scope = PROJECT_SCOPE_PREFIX + scopeRoot;
+    if (counts.persisted === 1 && counts.deduped === 0)
+        return receipt({ kind: 'applied', outcome: 'persisted', rule: storedRule, scope });
+    if (counts.deduped === 1 && counts.persisted === 0)
+        return receipt({ kind: 'applied', outcome: 'already_live', rule: storedRule, scope });
+    return receipt({ kind: 'unknown', cause: 'receipt_unreadable' });
+}

package/dist/hitl/parkResolver.js

@@ -1,15 +1,16 @@
-import { putOwnKey, readOwnDataValue } from '../ownKey.js';
+import { guardedRead, putOwnKey, readOwnDataValue } from '../ownKey.js';
 import { HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, isNoDecisionSurfaceReason, } from './hitlBridge.js';
 import { approvalResolutionDetail, approvalResolutionStatusTag, directSafetyStopOf, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
-import { INTERRUPT_DENY_REASON, observeCancelByDeny } from './hitlHostSurface.js';
+import { INTERRUPT_DENY_REASON, interruptDenyLifetime, observeCancelByDeny } from './hitlHostSurface.js';
 import { denyAttributionOf, flushHeldWithInterruptRewrite, isAskTool } from './frameRouter.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { inheritFrameBinding } from '../frameBinding.js';
 import { approvalCallKey, askGateQuestionId } from './gateIdentity.js';
+import { parkQuestionFrameBits, sourceGenerationNow } from './screenCardCarriers.js';
 import { usableAskQuestions } from './parkOwnership.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { decideFailureNote } from '../decideFailureNote.js';
@@ -65,6 +66,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
     if (!hasQuestionOverlay()) {
         return { kind: 'not_sent', lane: 'ask', cause: 'card_unavailable', detail: NO_QUESTION_OVERLAY_REASON };
     }
+    const sourceGeneration = sourceGenerationNow(deps);
     const found = await findPendingForTask(deps.client, taskId, isAskTool, signal ? { signal } : undefined, parkGatedCallId, (row) => isAskTool(typeof row.toolName === 'string' ? row.toolName : undefined));
     if (!found.ok)
         return { kind: 'not_sent', lane: 'ask', cause: found.code ?? 'fetch_failed', ...(found.reason !== '' ? { detail: found.reason } : {}), ...(found.rowVerdict !== undefined ? { rowVerdict: found.rowVerdict } : {}) };
@@ -113,7 +115,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         }
         signal?.addEventListener('abort', onAbort, { once: true });
         onPresented?.();
-        publishQuestionFrame({ type: 'question', questionId, questions, ...(questionsFromModelCall ? { _sema_questionsFromModelCall: true } : {}) });
+        publishQuestionFrame({ type: 'question', questionId, questions, ...(questionsFromModelCall ? { _sema_questionsFromModelCall: true } : {}), ...parkQuestionFrameBits(taskId, gatedCallId, sourceGeneration) });
     });
     if (withdrawn !== undefined) {
         hostLog('debug', `liveHitlAskWire: question-withdrawn-by-host card=${questionId} verdict=${withdrawn.rowVerdict.kind}`);
@@ -121,7 +123,7 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
     }
     const bridge = new HitlBridge(deps.client, taskId, deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : undefined);
     if (answer === null) {
-        observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, undefined, pending), taskId);
+        observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, { signal: interruptDenyLifetime() }, pending), taskId);
         return { kind: 'unsettled', ...at, cause: 'interrupted' };
     }
     let declinedReceipt;
@@ -194,6 +196,7 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
             ...(onPresented ? { onPresented } : {}),
             ...(deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : {}),
             ...(decidedByReading !== undefined ? { approvalDecidedBy: decidedByReading } : {}),
+            ...((read) => (typeof read === 'function' ? { engineGeneration: () => read.call(deps) } : {}))(guardedRead(() => deps.engineGeneration)),
         }, taskId, argsByCallOf(led), ctx.signal, gatedCallId, park.toolName);
         if (outcome.kind === 'decided' && outcome.decision === 'deny' && outcome.gatedCallId) {
             led.markDenied(outcome.gatedCallId, denyAttributionOf(outcome.deny));

package/dist/hitl/persistedRulesWire.d.ts

@@ -44,6 +44,11 @@ export interface CcImportRedeemCounts {
 }
 export type CcImportReceiptOutcome = 'persisted' | 'no-op' | 'refused' | 'indeterminate';
 export declare function readCcImportRedeemCounts(body: unknown): CcImportRedeemCounts | null;
+export interface CcImportRefusedReading {
+    readonly count: number;
+    readonly rows: readonly CcImportRedeemRefused[];
+}
+export declare function refusedRowOf(counts: CcImportRedeemCounts | null | undefined): CcImportRefusedReading | null;
 export type RulesFailure = {
     kind: 'lane-unavailable';
     message: string;
@@ -189,6 +194,17 @@ export declare function classifySkippedReason(reason: string): {
     code?: string;
     text: string;
 };
+export interface CcImportSkippedGroup {
+    readonly entries: readonly string[];
+    readonly reason: string;
+    readonly code?: string;
+}
+export interface CcImportSkippedReading {
+    readonly shape: 'absent' | 'malformed' | 'read';
+    readonly groups: readonly CcImportSkippedGroup[];
+    readonly unreadable: number;
+}
+export declare function ccImportSkippedRowsOf(skipped: {} | null | undefined): CcImportSkippedReading;
 export type RulePersistOutcome = {
     state: 'unknown';
 } | {