@sema-agent/client-core 0.110.0 → 0.112.0

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,70 @@
+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 interface LocalAllowDeclaredFacts {
+    readonly source: HostSettingsLayer;
+    readonly workspace: WorkspaceTrustState | 'unreadable';
+    readonly managedRulesOnly: boolean | 'unreadable';
+    readonly scopeRoot: string | undefined;
+    readonly store: ListAllPersistedRulesOutcome;
+}
+export type LocalAllowRedeemabilityInput = ({
+    readonly subject: 'offered';
+} & LocalAllowOfferedFacts) | ({
+    readonly subject: 'declared';
+    readonly rule: string;
+} & LocalAllowDeclaredFacts);
+export declare function localAllowRedeemability(input: LocalAllowRedeemabilityInput): LocalAllowRedeemability;
+export declare function localAllowLandingRedeemability(rule: {} | null | undefined, landing: {} | null | undefined): 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,276 @@
+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 function localAllowLandingRedeemability(rule, landing) {
+    try {
+        if (typeof rule !== 'string' || rule.trim() === '')
+            return unknownBecause('input_unreadable');
+        if (typeof landing !== 'object' || landing === null)
+            return unknownBecause('input_unreadable');
+        return localAllowRedeemability({
+            subject: 'declared',
+            rule,
+            source: readOwnDataValue(landing, 'source'),
+            workspace: readOwnDataValue(landing, 'workspace'),
+            managedRulesOnly: readOwnDataValue(landing, 'managedRulesOnly'),
+            scopeRoot: readOwnDataValue(landing, 'scopeRoot'),
+            store: readOwnDataValue(landing, 'store'),
+        });
+    }
+    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/parkOwnership.js

@@ -4,6 +4,7 @@ import { hostSessionFor } from '../host.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { pendingRowIsOfSession } from './parkRowDelegation.js';
 import { slotReadOf } from '../wireFailureShape.js';
+import { safetyStopNamed } from './hitlBridge.js';
 export function pendingRowIsOwnedByThisSession(row, deps) {
     return ownershipVerdictOf(row, deps) === 'owned';
 }
@@ -70,5 +71,5 @@ export function askQuestionsFromPending(pending) {
     return usableAskQuestions(input.questions);
 }
 export function isHitlSafetyErrorLike(e) {
-    return typeof e === 'object' && e !== null && e.name === 'HitlSafetyError';
+    return typeof e === 'object' && e !== null && safetyStopNamed(e);
 }

package/dist/hitl/parkResolver.js

@@ -1,21 +1,23 @@
-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';
 import { wireFailureTextsOf } from '../wireFailureShape.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { refusedParkFromError } from '../resumeRefusalCopy.js';
+import { decisionRefusalWayOutContent } from '../checkpointRowVerdict.js';
 export const MAX_GATE_HOPS = 2;
 export function nextHopBudget(prev, round) {
     const total = (prev?.total ?? 0) + 1;
@@ -65,6 +67,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 +116,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 +124,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 +197,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));
@@ -329,6 +333,10 @@ function failsoftWayOutOf(outcome) {
         return 'speak';
     if (outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing')))
         return 'reason';
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && outcome.refusal?.wayOut === 'newer_worker')
+        return 'newer_worker';
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && outcome.refusal?.wayOut === 'cancel_run')
+        return 'cancel';
     if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && (refusedParkFromError(outcome.refusal) !== null || outcome.refusal?.conflict === 'row_integrity'))
         return 'cancel';
     if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused')
@@ -345,6 +353,8 @@ function failsoftReasonSentence(park, failedReason, terminal, wayOut) {
         return renderMessage(msg('approval.park.stillParked', { gate, reason: failedReason }));
     if (wayOut === 'cancel')
         return renderMessage(msg('approval.park.refusedNotResumable', { gate, reason: failedReason }));
+    if (wayOut === 'newer_worker')
+        return renderMessage(msg('approval.park.newerWorker', { gate, reason: failedReason, wayOut: decisionRefusalWayOutContent('newer_worker') ?? '' }));
     return renderMessage(msg(wayOut === 'speak' ? 'approval.park.resume.speak' : 'approval.park.resume.card', { gate, reason: failedReason }));
 }
 function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface, wayOut) {

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';
 } | {

package/dist/hitl/persistedRulesWire.js

@@ -133,6 +133,35 @@ export function readCcImportRedeemCounts(body) {
         return null;
     }
 }
+const isCount = (r) => r.presence === 'present' && typeof r.value === 'number' && Number.isSafeInteger(r.value) && r.value >= 0;
+const NO_REFUSED_ROWS = Object.freeze([]);
+const NO_REFUSED = Object.freeze({ count: 0, rows: NO_REFUSED_ROWS });
+export function refusedRowOf(counts) {
+    try {
+        if (typeof counts !== 'object' || counts === null)
+            return null;
+        if (!isCount(slotReadOf(counts, 'persisted')) || !isCount(slotReadOf(counts, 'deduped')))
+            return null;
+        const slot = slotReadOf(counts, 'refused');
+        if (slot.presence === 'absent')
+            return NO_REFUSED;
+        if (slot.presence !== 'present')
+            return null;
+        const rows = ownArrayItems(slot.value);
+        if (rows === undefined)
+            return null;
+        const kept = [];
+        for (const row of rows) {
+            if (typeof row !== 'object' || row === null)
+                return null;
+            kept.push(row);
+        }
+        return kept.length === 0 ? NO_REFUSED : Object.freeze({ count: kept.length, rows: Object.freeze(kept) });
+    }
+    catch {
+        return null;
+    }
+}
 export function classifyRulesFailure(e, context) {
     const { status, errorCode, message, retryAfterSec, committed } = wireFailureShapeOf(e);
     if (errorCode === 'capability.rule_store_required') {
@@ -635,6 +664,47 @@ export function classifySkippedReason(reason) {
         return { text };
     return { code: head, text };
 }
+const CC_IMPORT_SKIPPED_READ_BUDGET = 20_000;
+const CC_IMPORT_SKIPPED_SHOWN_MAX = 2000;
+function ccImportSkippedReading(shape, groups, unreadable) {
+    return Object.freeze({ shape, groups: Object.freeze([...groups]), unreadable });
+}
+export function ccImportSkippedRowsOf(skipped) {
+    if (skipped === undefined)
+        return ccImportSkippedReading('absent', [], 0);
+    const grouped = new Map();
+    let unreadable = 0;
+    try {
+        if (!Array.isArray(skipped))
+            return ccImportSkippedReading('malformed', [], 0);
+        const length = readOwnDataValue(skipped, 'length');
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > CC_IMPORT_SKIPPED_READ_BUDGET)
+            return ccImportSkippedReading('malformed', [], 0);
+        for (let i = 0; i < length; i++) {
+            const row = guardedRead(() => readOwnDataValue(skipped, String(i)));
+            const rule = typeof row === 'object' && row !== null ? guardedRead(() => readOwnDataValue(row, 'rule')) : undefined;
+            const reason = typeof row === 'object' && row !== null ? guardedRead(() => readOwnDataValue(row, 'reason')) : undefined;
+            if (typeof rule !== 'string' || typeof reason !== 'string') {
+                unreadable += 1;
+                continue;
+            }
+            const entries = grouped.get(reason);
+            if (entries === undefined)
+                grouped.set(reason, [displayUntrusted(rule, { max: CC_IMPORT_SKIPPED_SHOWN_MAX })]);
+            else
+                entries.push(displayUntrusted(rule, { max: CC_IMPORT_SKIPPED_SHOWN_MAX }));
+        }
+    }
+    catch {
+        return ccImportSkippedReading('malformed', [], 0);
+    }
+    const groups = [];
+    for (const [raw, entries] of grouped) {
+        const code = classifySkippedReason(raw).code;
+        groups.push(Object.freeze({ entries: Object.freeze(entries), reason: displayUntrusted(raw, { max: CC_IMPORT_SKIPPED_SHOWN_MAX }), ...(code !== undefined ? { code } : {}) }));
+    }
+    return ccImportSkippedReading('read', groups, unreadable);
+}
 export function readRulePersistOutcome(ack) {
     const parsed = readToolApprovalRespondAck(ack);
     if (parsed === undefined || isToolApprovalRespondReplayed(parsed) || isToolApprovalRespondParkedRedeemed(parsed))