@sema-agent/client-core 0.92.0 → 0.93.1

package/dist/hitl/toolApprovalWire.js

@@ -1,15 +1,16 @@
 import { APPROVAL_CARD_PORT_KEY_MISMATCH_REASON, DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, NO_APPROVAL_CARD_PORT_REASON, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
 import { askParkRowArm } from './askParkRowRouting.js';
 import { hostLog } from '../host.js';
-import { readOwnNonEmptyString } from '../ownKey.js';
+import { readOwnDataNonEmptyString, readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPair } from './askClassPair.js';
 import { legacyShadowedRuleTextOf, readAllowRuleShadowFromWire } from './allowRuleShadow.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
-import { observeCancelByDeny, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
+import { observeCancelByDeny, surfaceApprovalParking, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceEditRefusedOnBlindAsk, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { isApprovalMandateWord } from '../gateVocabulary.js';
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
+import { approvalDecidedByAdmitted } from '../approvalDecidedByCapability.js';
 import { decideFailureNote } from '../decideFailureNote.js';
 import { refusalSaysStillPending } from '../engineErrorCodes.js';
 import { readDecideReceipt } from '../decideReceipt.js';
@@ -169,10 +170,117 @@ function isParkRowInputSizeMarker(v) {
     const o = v;
     return o.truncated === true && typeof o.bytes === 'number' && Number.isFinite(o.bytes) && o.bytes >= 0;
 }
+const durableDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), clock: 0 };
+function durableHoldKey(row, callKey) {
+    return JSON.stringify([typeof row.sessionId === 'string' ? row.sessionId : null, typeof row.taskId === 'string' ? row.taskId : null, callKey]);
+}
+function openDurableRead() {
+    const mark = ++durableDecisionHolds.clock;
+    durableDecisionHolds.openReads.add(mark);
+    return mark;
+}
+function closeDurableRead(mark) {
+    const h = durableDecisionHolds;
+    h.openReads.delete(mark);
+    let oldest = Infinity;
+    for (const m of h.openReads)
+        if (m < oldest)
+            oldest = m;
+    for (const [key, s] of h.settled)
+        if (s.at <= oldest)
+            h.settled.delete(key);
+}
+function heldDurableDecision(holdKey, readMark) {
+    const live = durableDecisionHolds.inFlight.get(holdKey);
+    if (live !== undefined)
+        return live;
+    const recent = durableDecisionHolds.settled.get(holdKey);
+    return recent !== undefined && recent.at > readMark ? recent.hold : undefined;
+}
+function holdDurableDecision(holdKey, callerSignal, decide) {
+    const h = durableDecisionHolds;
+    const interruption = new AbortController();
+    let settled = false;
+    const interrupt = () => {
+        if (!settled && !interruption.signal.aborted)
+            interruption.abort();
+    };
+    if (callerSignal?.aborted === true)
+        interrupt();
+    else
+        callerSignal?.addEventListener('abort', interrupt, { once: true });
+    let resolveOutcome = () => { };
+    let rejectOutcome = () => { };
+    const outcome = new Promise((resolve, reject) => {
+        resolveOutcome = resolve;
+        rejectOutcome = reject;
+    });
+    const hold = { outcome, presented: false, interrupt, cardSignal: interruption.signal };
+    h.inFlight.set(holdKey, hold);
+    const release = () => {
+        if (h.inFlight.get(holdKey) === hold)
+            h.inFlight.delete(holdKey);
+        if (h.openReads.size > 0)
+            h.settled.set(holdKey, { at: ++h.clock, hold });
+    };
+    const settle = (give) => {
+        settled = true;
+        callerSignal?.removeEventListener('abort', interrupt);
+        const trailing = hold.trailing;
+        if (trailing === undefined) {
+            release();
+            give();
+            return;
+        }
+        give();
+        trailing.then(release, release);
+    };
+    decide(hold).then((o) => settle(() => resolveOutcome(o)), (e) => settle(() => rejectOutcome(e)));
+    return outcome;
+}
+async function joinDurableDecision(hold, deps, signal) {
+    if (signal?.aborted === true)
+        hold.interrupt();
+    else
+        signal?.addEventListener('abort', hold.interrupt, { once: true });
+    let o;
+    try {
+        o = await hold.outcome;
+    }
+    finally {
+        signal?.removeEventListener('abort', hold.interrupt);
+    }
+    if (hold.presented) {
+        try {
+            deps.onPresented?.();
+        }
+        catch {
+        }
+    }
+    return { ...o, joinedInFlight: true };
+}
 export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signal, parkGatedCallId) {
-    const found = await findPendingForTask(deps.client, taskId, (toolName) => toolName !== undefined && (toolNameIsFsWrite(toolName) || toolNameIsShellExec(toolName)), signal ? { signal } : undefined, parkGatedCallId, (row) => askParkRowArm(row) === 'tool-gate');
+    const decidedByReading = decidedByReadingSnapshotOf(deps);
+    const readMark = openDurableRead();
+    let found;
+    let held;
+    try {
+        found = await findPendingForTask(deps.client, taskId, (toolName) => toolName !== undefined && (toolNameIsFsWrite(toolName) || toolNameIsShellExec(toolName)), signal ? { signal } : undefined, parkGatedCallId, (row) => askParkRowArm(row) === 'tool-gate');
+        if (found.ok)
+            held = heldDurableDecision(durableHoldKey(found.pending, approvalCallKey(found.gatedCallId, taskId)), readMark);
+    }
+    finally {
+        closeDurableRead(readMark);
+    }
     if (!found.ok)
         return { kind: 'failed', stage: 'fetch', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
+    if (held !== undefined)
+        return joinDurableDecision(held, deps, signal);
+    const callKey = approvalCallKey(found.gatedCallId, taskId);
+    const fetched = found;
+    return holdDurableDecision(durableHoldKey(fetched.pending, callKey), signal, (hold) => presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, fetched, decidedByReading, callKey, hold));
+}
+async function presentFsApprovalAndDecide(deps, taskId, argsByCall, signal, found, decidedByReading, callKey, hold) {
     const { pending, gatedCallId } = found;
     const toolName = typeof pending.toolName === 'string' ? pending.toolName : '';
     const streamArgs = gatedCallId !== undefined ? argsByCall.get(gatedCallId) : undefined;
@@ -189,18 +297,18 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         return { kind: 'failed', stage: 'input', gatedCallId, reason: 'gate has no tool input payload' };
     }
     const bridge = new HitlBridge(deps.client, taskId, deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : undefined);
-    const callKey = approvalCallKey(gatedCallId, taskId);
-    const ruleOffersReadOnly = readRuleOfferSupply(pending.ruleOffers, pending.ruleSuggestions);
+    const ruleOffersReadOnly = readRuleOffers(pending.ruleOffers);
     const durableProbeCause = pending.riskDescriptor?.probeCause;
     const durableProbeReason = readProbeReason(pending.riskDescriptor);
     const durableShadow = readAllowRuleShadowFromWire(pending, 'row');
     const durableRuleOffersAbsence = pending.ruleOffersAbsence;
+    hold.presented = true;
     deps.onPresented?.();
     const card = await surfaceApprovalCard({
         toolName,
         args,
         callKey,
-        ...(signal ? { signal } : {}),
+        signal: hold.cardSignal,
         ...(rowArgsGap !== undefined
             ? {
                 argsUnavailable: true,
@@ -243,7 +351,11 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                 hostLog('debug', `liveHitlAskWire: approval card retracted without a decision for ${gatedCallId ?? '(no call)'} — nothing sent`);
                 return { kind: 'retracted', gatedCallId };
             case 'aborted':
-                observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: 'Interrupted by user' }, gatedCallId, undefined, pending), taskId);
+                {
+                    const cancelDeny = bridge.decideTool({ decision: 'deny', reason: 'Interrupted by user' }, gatedCallId, undefined, pending);
+                    hold.trailing = cancelDeny;
+                    observeCancelByDeny(cancelDeny, taskId);
+                }
                 return { kind: 'aborted', gatedCallId };
             case 'allow':
                 try {
@@ -295,31 +407,56 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                 }
             case 'deny': {
                 const denySettledByForWire = readApprovalDenySettledBy(card);
+                const attributionKeys = decisionAttributionKeyOf(decidedByReading, denySettledByForWire);
                 const denyReasonSnapshot = typeof card.reason === 'string' ? card.reason : undefined;
                 let lastSendCarriedAttribution = false;
                 try {
                     const denyBody = {
                         decision: 'deny',
                         reason: denyReasonForWire(denyReasonSnapshot, `task ${taskId}`) ?? DEFAULT_DENY_REASON,
-                        ...(denySettledByForWire === 'policy' ? { settledBy: 'policy' } : {}),
+                        ...attributionKeys,
                     };
                     let attributionDropped = false;
+                    let attributionRenamed = false;
                     let raw;
-                    lastSendCarriedAttribution = denySettledByForWire === 'policy';
+                    lastSendCarriedAttribution = carriesAttributionKey(attributionKeys);
                     try {
                         raw = await bridge.decideTool(denyBody, gatedCallId, decideOpts, pending);
                     }
                     catch (first) {
-                        if (!shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal))
+                        if (shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal)) {
+                            const withoutAttribution = withoutAttributionKey(denyBody);
+                            lastSendCarriedAttribution = false;
+                            hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note is not part of ` +
+                                'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
+                                '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
+                            raw = await bridge.decideTool(withoutAttribution, gatedCallId, decideOpts, pending);
+                            attributionDropped = true;
+                        }
+                        else if (shouldResendUnderSuccessorKey(first, Object.hasOwn(denyBody, 'settledBy'), signal)) {
+                            const renamed = withAttributionKeyRenamed(denyBody);
+                            hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note was sent under a name ` +
+                                'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
+                                '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
+                            try {
+                                raw = await bridge.decideTool(renamed, gatedCallId, decideOpts, pending);
+                                attributionRenamed = true;
+                            }
+                            catch (second) {
+                                if (!shouldResendWithoutAttribution(second, true, signal))
+                                    throw second;
+                                const renamedWithoutAttribution = withoutAttributionKey(renamed);
+                                lastSendCarriedAttribution = false;
+                                hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused again because the settlement note is not part of ` +
+                                    'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
+                                    '(still before the approval was judged)');
+                                raw = await bridge.decideTool(renamedWithoutAttribution, gatedCallId, decideOpts, pending);
+                                attributionDropped = true;
+                            }
+                        }
+                        else {
                             throw first;
-                        const { settledBy: _droppedKey, ...withoutAttribution } = denyBody;
-                        void _droppedKey;
-                        lastSendCarriedAttribution = false;
-                        hostLog('debug', `liveToolApprovalWire: decide(deny) for task ${taskId} was refused because the settlement note is not part of ` +
-                            'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
-                            '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
-                        raw = await bridge.decideTool(withoutAttribution, gatedCallId, decideOpts, pending);
-                        attributionDropped = true;
+                        }
                     }
                     const receipt = readDecideReceipt(raw);
                     const denySettledBy = denySettledByForWire;
@@ -331,6 +468,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                         ...(denySettledBy !== undefined ? { denySettledBy } : {}),
                         ...(denyReason !== undefined ? { denyReason } : {}),
                         ...(attributionDropped ? { denyAttributionDropped: true } : {}),
+                        ...(attributionRenamed ? { denyAttributionRenamed: true } : {}),
                         ...(receipt !== undefined ? { receipt } : {}),
                     };
                 }
@@ -360,6 +498,8 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
         decideSpan.close();
     }
 }
+const _boundGrantsPin = [true, true, true];
+void _boundGrantsPin;
 function readReadRootCandidate(v) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -382,11 +522,9 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'args',
     'argsOmitted',
     'governanceForced',
-    'ruleSuggestions',
     'ruleOffers',
     'ruleOffersAbsence',
     'denialLimitFallback',
-    'ruleStoreUnreadable',
     'readRootCandidate',
     'mandated',
     'mandate',
@@ -400,6 +538,9 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'probeCause',
     'probeReason',
     'rememberRefused',
+    'boundGrantDigest',
+    'boundGrants',
+    'classifierNoRuling',
     'ruleEvidence',
     'requiresRealApproval',
     'expiresInMs',
@@ -515,6 +656,27 @@ export function readToolApprovalRespondAck(v) {
     }
     return out;
 }
+function readToolApprovalRespondParking(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    const read = (fn) => {
+        try {
+            return fn();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    if (read(() => readOwnDataNonEmptyString(v, 'reason')) !== 'parking_in_progress')
+        return undefined;
+    const approvalId = read(() => readOwnDataNonEmptyString(v, 'approvalId'));
+    if (approvalId === undefined)
+        return { kind: 'claimed_unreadable' };
+    const hint = read(() => readOwnDataValue(v, 'retryAfterMs'));
+    const retryAfterMs = typeof hint === 'number' && Number.isFinite(hint) && hint >= 0 ? hint : undefined;
+    const decidePath = read(() => readOwnDataNonEmptyString(v, 'decidePath'));
+    return { kind: 'parking', view: { approvalId, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), ...(decidePath !== undefined ? { decidePath } : {}) } };
+}
 function isNonEmptyStringArray(v) {
     return Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string' && x !== '');
 }
@@ -550,13 +712,50 @@ function readPersistedRuleAnchors(v) {
 function isNonNegativeSafeInt(v) {
     return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
 }
-function shouldResendWithoutAttribution(e, sentSettledBy, signal) {
-    if (!sentSettledBy)
+function shouldResendWithoutAttribution(e, sentAttributionKey, signal) {
+    if (!sentAttributionKey)
         return false;
     if (signal?.aborted === true)
         return false;
     return denyAttributionRefusalFromError(e, true)?.kind === 'not_in_proof';
 }
+function shouldResendUnderSuccessorKey(e, lastSendCarriedRetiredKey, signal) {
+    if (!lastSendCarriedRetiredKey)
+        return false;
+    if (signal?.aborted === true)
+        return false;
+    return denyAttributionRefusalFromError(e, true)?.kind === 'retired_key';
+}
+export function decisionAttributionKeyOf(reading, denySettledBy) {
+    if (denySettledBy !== 'policy')
+        return {};
+    return approvalDecidedByAdmitted(reading) ? { decidedBy: 'policy' } : { settledBy: 'policy' };
+}
+function carriesAttributionKey(body) {
+    return Object.hasOwn(body, 'settledBy') || Object.hasOwn(body, 'decidedBy');
+}
+function withoutAttributionKey(body) {
+    const { settledBy: _droppedSettledBy, decidedBy: _droppedDecidedBy, ...rest } = body;
+    void _droppedSettledBy;
+    void _droppedDecidedBy;
+    return rest;
+}
+function withAttributionKeyRenamed(body) {
+    const { settledBy, decidedBy: _replaced, ...rest } = body;
+    void _replaced;
+    return settledBy === undefined ? rest : { ...rest, decidedBy: settledBy };
+}
+function readDecidedByReadingOf(holder) {
+    try {
+        return readOwnDataValue(holder, 'approvalDecidedBy');
+    }
+    catch {
+        return undefined;
+    }
+}
+function decidedByReadingSnapshotOf(holder) {
+    return approvalDecidedByAdmitted(readDecidedByReadingOf(holder)) ? Object.freeze({ kind: 'present', value: true }) : undefined;
+}
 export function readToolApprovalRespondRefusal(err) {
     const pick = (key) => {
         try {
@@ -789,24 +988,8 @@ export function readRuleOffers(v) {
     }
     return out.length > 0 ? out : undefined;
 }
-function readLegacyRuleSuggestions(v) {
-    if (!Array.isArray(v))
-        return undefined;
-    if (v.length === 0 || v.length > MAX_RULE_OFFERS_TOLERATED)
-        return undefined;
-    const out = [];
-    for (let i = 0; i < v.length; i++) {
-        const triple = readRuleTriple(v[i]);
-        if (triple === undefined)
-            continue;
-        out.push({ kind: 'single', offerIndex: i, ...triple });
-    }
-    return out.length > 0 ? out : undefined;
-}
-export function readRuleOfferSupply(offers, legacy) {
-    if (offers !== undefined && offers !== null)
-        return readRuleOffers(offers);
-    return readLegacyRuleSuggestions(legacy);
+export function readRuleOfferSupply(offers) {
+    return readRuleOffers(offers);
 }
 function subagentBadgeFor(frame) {
     let name = typeof frame.sourceAgentName === 'string' && frame.sourceAgentName.length > 0 ? frame.sourceAgentName : '';
@@ -830,6 +1013,7 @@ const MAX_RESPOND_NOTE_CHARS = 2048;
 export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamArgs, signal, lane) {
     const approvalId = frame.approvalId;
     const frameToolCallId = typeof frame.toolCallId === 'string' && frame.toolCallId !== '' ? frame.toolCallId : undefined;
+    const decidedByReading = decidedByReadingSnapshotOf(lane);
     const toolName = typeof frame.toolName === 'string' ? frame.toolName : 'Write';
     let args = streamArgs !== undefined && streamArgs !== null
         ? streamArgs
@@ -854,7 +1038,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         }
     }
     const argsNotRealInput = argsFallback || lane?.argsUnavailable === true;
-    const ruleOffers = readRuleOfferSupply(frame.ruleOffers, frame.ruleSuggestions);
+    const ruleOffers = readRuleOffers(frame.ruleOffers);
     const denialLimitFallback = readDenialLimitFallback(frame.denialLimitFallback);
     const frameShadow = readAllowRuleShadowFromWire(frame, 'frame');
     const card = await surfaceApprovalCard({
@@ -912,8 +1096,9 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
     }
     const decision = card.kind === 'allow' ? (card.allowSession ? 'allow_session' : 'allow') : 'deny';
     const denySettledByForWire = card.kind === 'deny' ? readApprovalDenySettledBy(card) : undefined;
-    const sentSettledBy = decision === 'deny' && denySettledByForWire === 'policy';
-    let lastSendCarriedAttribution = sentSettledBy;
+    const attributionKeys = decision === 'deny' ? decisionAttributionKeyOf(decidedByReading, denySettledByForWire) : {};
+    const sentAttributionKey = carriesAttributionKey(attributionKeys);
+    let lastSendCarriedAttribution = sentAttributionKey;
     const denyReasonSnapshot = card.kind === 'deny' && typeof card.reason === 'string' ? card.reason : undefined;
     if (card.kind === 'failed') {
         hostLog('debug', `liveToolApprovalWire: approval card unavailable (${card.reason}) — fail-closed deny for ${approvalId}`);
@@ -940,14 +1125,14 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         let persistRuleBatchOfferIndex;
         let batchArmTarget;
         let ruleArmDroppedForCaps = false;
-        let ruleArmDroppedForCheck = false;
+        let ruleArmDroppedForCheck;
         const wantsTextArm = card.kind === 'allow' && typeof card.persistRule === 'string' && card.persistRule !== '';
         const wantsBatchArm = card.kind === 'allow' && card.persistRuleBatchOfferIndex !== undefined;
         if (wantsTextArm && wantsBatchArm) {
             hostLog('error', `liveToolApprovalWire: DROPPING the whole persistRule arm for ${approvalId} — the card returned BOTH a rule ` +
                 'text and a batchOfferIndex; the server rejects that combination with a 400 that would take the decision down ' +
                 'with it, and picking one arm here would be deciding on the user\'s behalf (the decision itself still goes through)');
-            ruleArmDroppedForCheck = true;
+            ruleArmDroppedForCheck = 'both_arms';
         }
         else if (card.kind === 'allow' &&
             card.persistRuleBatchOfferIndex !== undefined &&
@@ -972,7 +1157,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
                 hostLog('error', `liveToolApprovalWire: DROPPING persistRuleBatchOfferIndex(${String(idx)}) for ${approvalId} — that wire ` +
                     'index is not a batch offer on this frame (out of range, a single offer, or not a non-negative integer); ' +
                     'never redeeming an index the engine did not offer as a batch');
-                ruleArmDroppedForCheck = true;
+                ruleArmDroppedForCheck = 'index_not_a_batch_offer';
             }
         }
         else if (wantsTextArm && card.kind === 'allow' && typeof card.persistRule === 'string' && decision !== 'deny') {
@@ -994,7 +1179,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             }
             else {
                 hostLog('error', `liveToolApprovalWire: DROPPING persistRule for ${approvalId} — the card returned a rule that is not among the frame's SINGLE offers (a batch member's text is not a selectable candidate either: a conjunction batch is redeemed by index, all-or-nothing) — never sending un-offered text to the rule store`);
-                ruleArmDroppedForCheck = true;
+                ruleArmDroppedForCheck = 'text_not_offered';
             }
         }
         const respondOpts = {
@@ -1004,24 +1189,61 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             ...(persistRuleEdited !== undefined ? { persistRuleEdited } : {}),
             ...(persistRuleBatchOfferIndex !== undefined ? { persistRuleBatchOfferIndex } : {}),
             ...(note !== undefined ? { note } : {}),
-            ...(sentSettledBy ? { settledBy: 'policy' } : {}),
+            ...attributionKeys,
         };
         let attributionDropped = false;
+        let attributionRenamed = false;
         let raw;
         try {
             raw = await respond(approvalId, decision, respondOpts);
         }
         catch (first) {
-            if (!shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal))
+            if (shouldResendWithoutAttribution(first, lastSendCarriedAttribution, signal)) {
+                const withoutAttribution = withoutAttributionKey(respondOpts);
+                lastSendCarriedAttribution = false;
+                hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note is not part of ` +
+                    'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
+                    '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
+                raw = await respond(approvalId, decision, withoutAttribution);
+                attributionDropped = true;
+            }
+            else if (shouldResendUnderSuccessorKey(first, Object.hasOwn(respondOpts, 'settledBy'), signal)) {
+                const renamed = withAttributionKeyRenamed(respondOpts);
+                hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note was sent under a name ` +
+                    'this engine has retired — re-sending the SAME decision exactly once with that one key renamed to the name the refusal points to ' +
+                    '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
+                try {
+                    raw = await respond(approvalId, decision, renamed);
+                    attributionRenamed = true;
+                }
+                catch (second) {
+                    if (!shouldResendWithoutAttribution(second, true, signal))
+                        throw second;
+                    const renamedWithoutAttribution = withoutAttributionKey(renamed);
+                    lastSendCarriedAttribution = false;
+                    hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused again because the settlement note is not part of ` +
+                        'what this deployment signs — re-sending the SAME decision exactly once more with that key removed ' +
+                        '(still before the approval was judged)');
+                    raw = await respond(approvalId, decision, renamedWithoutAttribution);
+                    attributionDropped = true;
+                }
+            }
+            else {
                 throw first;
-            const { settledBy: _droppedKey, ...withoutAttribution } = respondOpts;
-            void _droppedKey;
-            lastSendCarriedAttribution = false;
-            hostLog('debug', `liveToolApprovalWire: respond(deny) for ${approvalId} was refused because the settlement note is not part of ` +
-                'what this deployment signs — re-sending the SAME decision exactly once with that one key removed ' +
-                '(the refusal happened before the approval was judged, so nothing was consumed and this is a re-delivery, not a second act)');
-            raw = await respond(approvalId, decision, withoutAttribution);
-            attributionDropped = true;
+            }
+        }
+        const parkingBody = readToolApprovalRespondParking(raw);
+        if (parkingBody !== undefined) {
+            const parking = parkingBody.kind === 'parking' && parkingBody.view.approvalId === approvalId ? parkingBody.view : undefined;
+            if (parking !== undefined) {
+                hostLog('debug', `liveToolApprovalWire: respond(${decision}) for ${approvalId} answered 202 parking_in_progress${parking.retryAfterMs !== undefined ? ` (retryAfterMs=${parking.retryAfterMs})` : ''} — ` +
+                    `the answer did NOT take effect${parking.decidePath !== undefined ? ' (the engine pointed at a decide path for the parked card)' : ''}; not re-sent, not reported as decided; the user is told to answer again on the parked card`);
+                surfaceApprovalParking(parking.retryAfterMs);
+                return { decision: 'unresolved', parking };
+            }
+            hostLog('error', `liveToolApprovalWire: 202 parking body for ${approvalId} is ${parkingBody.kind === 'parking' ? `for another approval (${parkingBody.view.approvalId})` : 'unreadable (approvalId is not usable)'} — ` +
+                'reporting the answer as NOT settled (never as decided, never as parked); not re-sent');
+            return { decision: 'unresolved' };
         }
         const parsed = readToolApprovalRespondAck(raw);
         let ack = parsed;
@@ -1077,8 +1299,8 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         }
         if (ruleArmDroppedForCaps)
             surfaceRuleArmNotSent();
-        if (ruleArmDroppedForCheck)
-            surfaceRuleArmRejected();
+        if (ruleArmDroppedForCheck !== undefined)
+            surfaceRuleArmRejected(ruleArmDroppedForCheck);
         if (decision === 'allow_session' && ack?.rememberApplied === false) {
             logAfterDecided(`liveToolApprovalWire: ${approvalId} allow_session ack rememberApplied=false — grant not stored, surfacing honest notice`);
             surfaceRememberNotApplied();
@@ -1094,6 +1316,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         const denyAttribution = decision === 'deny'
             ? {
                 ...(attributionDropped ? { denyAttributionDropped: true } : {}),
+                ...(attributionRenamed ? { denyAttributionRenamed: true } : {}),
                 ...(denySettledByForWire !== undefined ? { denySettledBy: denySettledByForWire } : {}),
                 ...(denyReasonSnapshot !== undefined && denyReasonSnapshot.trim() !== ''
                     ? { denyReason: denyReasonSnapshot }

package/dist/hooksWireCaps.d.ts

@@ -1,7 +1,7 @@
 import { type HooksWirePlan, type HooksWirePlanOptions } from './pluginHooksWire.js';
 import { type HookFailureNotice } from './notifications.js';
 import type { WireHooksConfig } from './finalVerifyWire.js';
-export { GOAL_STOP_HOOK_WIRE_ENV, CC_STOP_SEMANTICS_MIN_SERVER, ccStopSemanticsFromVersion, engineCcStopSemantics, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, getWireSessionStopHookCcSemantics, buildGoalStopHookPrompt, } from './goalStopHook.js';
+export { GOAL_STOP_HOOK_WIRE_ENV, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, } from './goalStopHook.js';
 export type { WireHooksConfig };
 export interface HooksForWireOptions {
     readonly plan?: HooksWirePlan;

package/dist/hooksWireCaps.js

@@ -5,7 +5,7 @@ import { hostLog, hostSettings } from './host.js';
 import { createSettingsHookJudge, decidePluginHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, occupancyOf, settingsHookDropText, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
-export { GOAL_STOP_HOOK_WIRE_ENV, CC_STOP_SEMANTICS_MIN_SERVER, ccStopSemanticsFromVersion, engineCcStopSemantics, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, getWireSessionStopHookCcSemantics, buildGoalStopHookPrompt, } from './goalStopHook.js';
+export { GOAL_STOP_HOOK_WIRE_ENV, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, } from './goalStopHook.js';
 const EDITABLE_HOOK_SOURCES = ['userSettings', 'projectSettings', 'localSettings'];
 const ALL_HOOK_SOURCES = ['policySettings', ...EDITABLE_HOOK_SOURCES, 'flagSettings'];
 const _hookSourceListsPin = [true, true];

package/dist/index.d.ts

@@ -55,11 +55,16 @@ export * from './workflowsJournalCapability.js';
 export * from './userInvokedSkillsCapability.js';
 export * from './skillToolListsCapability.js';
 export * from './steerPriorityCapability.js';
+export * from './permissionModesCapability.js';
+export * from './approvalDecidedByCapability.js';
 export * from './mcpProbeWire.js';
 export * from './effectiveFacts.js';
 export * from './gateOutcome.js';
 export * from './postureKnob.js';
 export * from './engineIdentity.js';
+export { transportFailureScene } from './engineWireFor.js';
+export type { EngineWireNoAnswerKind, TransportFailureChainEnd, TransportFailureLayer, TransportFailureScene, TransportFailureSocket } from './engineWireFor.js';
+export * from './engineConfigDrift.js';
 export * from './gateVocabulary.js';
 export * from './permissionRuleIssue.js';
 export * from './toolRoster.js';
@@ -81,7 +86,7 @@ export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
 export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
 export { findSystemReminderOpenTag, type SystemReminderOpenTagSpan } from './systemReminderTag.js';
-export { ACTIVE_RUN_BUSY_ERROR_CODE, APPROVAL_EXPIRED, ASK_GONE, asModelFallbackReason, CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, CORRUPT_SESSION_ERROR_CODE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_PARK_MOVED_CODES, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, FLEET_LEASE_UNAVAILABLE, GATE_PARKED_ERROR_CODE, imageInvalidFailureNoteOf, isConfigRefusalCode, isCorruptSessionCode, isDecideParkMovedCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isRulesRefusalCode, isStatusDerivedCoarseCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, operatorGateRefusalContent, OUTPUT_INVALID, PARKED_RESUME_STARTUP_FAILED, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, RULES_LEGACY_TOOL_NAME, RUN_DEATH_VERDICT_CODES, RUN_ORPHANED, RUN_STALLED, runDeathVerdictNoteOf, SCENARIO_NOT_ALLOWED_ERROR_CODE, STATUS_DERIVED_COARSE_CODES, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
+export { ACTIVE_RUN_BUSY_ERROR_CODE, APPROVAL_EXPIRED, ASK_GONE, asModelFallbackReason, CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, CORRUPT_SESSION_ERROR_CODE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_PARK_MOVED_CODES, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, FLEET_LEASE_UNAVAILABLE, GATE_PARKED_ERROR_CODE, imageInvalidFailureNoteOf, isConfigRefusalCode, isCorruptSessionCode, isDecideParkMovedCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isRulesRefusalCode, isStatusDerivedCoarseCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, operatorGateRefusalContent, OUTPUT_INVALID, PARKED_RESUME_STARTUP_FAILED, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, RULES_LEGACY_TOOL_NAME, RUN_DEATH_VERDICT_CODES, RUN_ORPHANED, RUN_STALLED, runDeathVerdictNoteOf, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, SCENARIO_NOT_ALLOWED_ERROR_CODE, STATUS_DERIVED_COARSE_CODES, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
 export type { DelegationCapDisposition, ModelFallbackReason, OperatorGateRefusal, RunDeathVerdictCode, } from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
@@ -177,7 +182,7 @@ export type { AttachmentSeatReading } from './attachmentSeatCapability.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
-export { SUPPORT_FLOOR, supportFloorOf, engineVersionTier } from './supportFloor.js';
+export { SUPPORT_FLOOR, supportFloorOf, engineVersionTier, coreVersionTier } from './supportFloor.js';
 export type { SupportFloor, SupportFloorComponent, EngineVersionTier } from './supportFloor.js';
 export * from './decideReceipt.js';
 export * from './sessionMap.js';

package/dist/index.js

@@ -49,11 +49,15 @@ export * from './workflowsJournalCapability.js';
 export * from './userInvokedSkillsCapability.js';
 export * from './skillToolListsCapability.js';
 export * from './steerPriorityCapability.js';
+export * from './permissionModesCapability.js';
+export * from './approvalDecidedByCapability.js';
 export * from './mcpProbeWire.js';
 export * from './effectiveFacts.js';
 export * from './gateOutcome.js';
 export * from './postureKnob.js';
 export * from './engineIdentity.js';
+export { transportFailureScene } from './engineWireFor.js';
+export * from './engineConfigDrift.js';
 export * from './gateVocabulary.js';
 export * from './permissionRuleIssue.js';
 export * from './toolRoster.js';
@@ -73,7 +77,7 @@ export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
 export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
 export { findSystemReminderOpenTag } from './systemReminderTag.js';
-export { ACTIVE_RUN_BUSY_ERROR_CODE, APPROVAL_EXPIRED, ASK_GONE, asModelFallbackReason, CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, CORRUPT_SESSION_ERROR_CODE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_PARK_MOVED_CODES, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, FLEET_LEASE_UNAVAILABLE, GATE_PARKED_ERROR_CODE, imageInvalidFailureNoteOf, isConfigRefusalCode, isCorruptSessionCode, isDecideParkMovedCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isRulesRefusalCode, isStatusDerivedCoarseCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, operatorGateRefusalContent, OUTPUT_INVALID, PARKED_RESUME_STARTUP_FAILED, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, RULES_LEGACY_TOOL_NAME, RUN_DEATH_VERDICT_CODES, RUN_ORPHANED, RUN_STALLED, runDeathVerdictNoteOf, SCENARIO_NOT_ALLOWED_ERROR_CODE, STATUS_DERIVED_COARSE_CODES, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
+export { ACTIVE_RUN_BUSY_ERROR_CODE, APPROVAL_EXPIRED, ASK_GONE, asModelFallbackReason, CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, CORRUPT_SESSION_ERROR_CODE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_PARK_MOVED_CODES, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, FLEET_LEASE_UNAVAILABLE, GATE_PARKED_ERROR_CODE, imageInvalidFailureNoteOf, isConfigRefusalCode, isCorruptSessionCode, isDecideParkMovedCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isRulesRefusalCode, isStatusDerivedCoarseCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, operatorGateRefusalContent, OUTPUT_INVALID, PARKED_RESUME_STARTUP_FAILED, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, RULES_LEGACY_TOOL_NAME, RUN_DEATH_VERDICT_CODES, RUN_ORPHANED, RUN_STALLED, runDeathVerdictNoteOf, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, SCENARIO_NOT_ALLOWED_ERROR_CODE, STATUS_DERIVED_COARSE_CODES, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
 export * from './clientContextWireCaps.js';
@@ -155,7 +159,7 @@ export { noteEngineCapsForAttachmentSeat, observedAttachmentSeat, forgetAttachme
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
-export { SUPPORT_FLOOR, supportFloorOf, engineVersionTier } from './supportFloor.js';
+export { SUPPORT_FLOOR, supportFloorOf, engineVersionTier, coreVersionTier } from './supportFloor.js';
 export * from './decideReceipt.js';
 export * from './sessionMap.js';
 export * from './detachWire.js';