@sema-agent/client-core 0.92.0 → 0.93.0

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,12 +1,12 @@
 import { type GateCurrentPending, type HitlFailureStage, type HitlSafetyCode, type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
 import { type AllowRuleShadowedWireMember, type ApprovalAllowRuleShadow } from './allowRuleShadow.js';
-import { type RuleStoreUnreadableKind } from '../gateVocabulary.js';
 import { type ApprovalMandateWord } from '../gateVocabulary.js';
 import type { ToolPermissionRequest } from '../seatContract.js';
 import { type DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
+import { type ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecideReceiptView } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS } from '@sema-agent/sdk';
-import type { RuleSuggestion, ToolApprovalRespondAck, PersistedRuleAnchor as SdkPersistedRuleAnchor, RuleOfferMatch as SdkRuleOfferMatch, RuleOfferBatchMember as SdkRuleOfferBatchMember, RuleOfferUncoveredDetail as SdkRuleOfferUncoveredDetail, RuleOfferUncoveredReason as SdkRuleOfferUncoveredReason, AskOrigin as SdkAskOrigin, RuleOffersAbsence as SdkRuleOffersAbsence, DenialLimitKind as SdkDenialLimitKind, DenialLimitFallback as SdkDenialLimitFallback } from '@sema-agent/sdk';
+import type { ToolApprovalRespondAck, PersistedRuleAnchor as SdkPersistedRuleAnchor, RuleOfferMatch as SdkRuleOfferMatch, RuleOfferBatchMember as SdkRuleOfferBatchMember, RuleOfferUncoveredDetail as SdkRuleOfferUncoveredDetail, RuleOfferUncoveredReason as SdkRuleOfferUncoveredReason, AskOrigin as SdkAskOrigin, RuleOffersAbsence as SdkRuleOffersAbsence, DenialLimitKind as SdkDenialLimitKind, DenialLimitFallback as SdkDenialLimitFallback } from '@sema-agent/sdk';
 export declare function isFsApprovalGate(gate: {
     kind?: unknown;
     toolName?: unknown;
@@ -24,6 +24,7 @@ export type FsApprovalOutcome = {
     denySettledBy?: ApprovalDenySettledBy | undefined;
     denyReason?: string | undefined;
     denyAttributionDropped?: true;
+    denyAttributionRenamed?: true;
     receipt?: DecideReceiptView | undefined;
 } | {
     kind: 'aborted';
@@ -49,6 +50,7 @@ export interface FsApprovalWireDeps {
     client: HitlClientLike;
     onPresented?: () => void;
     onDecideOperation?: DecideOperationObserver;
+    approvalDecidedBy?: ApprovalDecidedByReading | undefined;
 }
 export declare function structurallyEqual(a: unknown, b: unknown): boolean;
 export type RuleOfferMatch = SdkRuleOfferMatch;
@@ -151,7 +153,6 @@ export interface ApprovalCardRequest {
     origin?: string;
     askClass?: string;
     classes?: readonly string[];
-    ruleStoreUnreadable?: RuleStoreUnreadableKind;
 }
 export type ApprovalCardPort = (req: ApprovalCardRequest) => Promise<ApprovalCardDecision>;
 export declare function installApprovalCardPort(port: ApprovalCardPort | null): () => void;
@@ -164,6 +165,11 @@ export declare function approvalCardPortFor(sessionKey: string): ApprovalCardPor
 export declare function _resetApprovalCardPortForTest(): void;
 export declare function surfaceApprovalCard(req: ApprovalCardRequest): Promise<ApprovalCardDecision>;
 export declare function surfaceFsApprovalAndDecide(deps: FsApprovalWireDeps, taskId: string, argsByCall: Map<string, unknown>, signal?: AbortSignal, parkGatedCallId?: string): Promise<FsApprovalOutcome>;
+export interface BoundSkillGrantsWire {
+    readonly skill: string | null;
+    readonly allowedTools: readonly string[];
+    readonly disallowedTools: readonly string[];
+}
 export interface ToolApprovalFrame {
     type: 'tool_approval' | 'tool_approval_complete';
     approvalId: string;
@@ -178,13 +184,14 @@ export interface ToolApprovalFrame {
     sourceAgentName?: string;
     governanceForced?: true;
     delegation?: ToolApprovalDelegation;
-    ruleSuggestions?: RuleSuggestion[];
     ruleOffers?: readonly WireRuleOffer[];
     ruleOffersAbsence?: string;
     denialLimitFallback?: DenialLimitFallback;
-    ruleStoreUnreadable?: string;
     persistedRuleShadowed?: string;
     allowRuleShadowed?: readonly AllowRuleShadowedWireMember[];
+    boundGrantDigest?: string;
+    boundGrants?: BoundSkillGrantsWire;
+    classifierNoRuling?: string;
     probeCause?: unknown;
     probeReason?: string;
     rememberRefused?: true;
@@ -212,7 +219,7 @@ export interface ToolApprovalDelegation {
     depth: number;
     agentName?: string;
 }
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleSuggestions", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "ruleStoreUnreadable", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
 export interface ApprovalMandatedFacts {
     readonly mandated?: true;
     readonly ruleOffersAbsence?: string;
@@ -233,11 +240,17 @@ export interface RespondToolApprovalOpts {
     persistRuleBatchOfferIndex?: number;
     note?: string;
     settledBy?: 'policy';
+    decidedBy?: 'policy';
 }
 export type RespondToolApprovalFn = (approvalId: string, decision: ToolApprovalRespondDecision, opts?: RespondToolApprovalOpts) => Promise<ToolApprovalRespondAck | void>;
 export type ToolApprovalRespondAckView = ToolApprovalRespondAck;
 export type PersistedRuleAnchor = SdkPersistedRuleAnchor;
 export declare function readToolApprovalRespondAck(v: unknown): ToolApprovalRespondAckView | undefined;
+export declare function decisionAttributionKeyOf(reading: ApprovalDecidedByReading | undefined, denySettledBy: ApprovalDenySettledBy | undefined): {
+    decidedBy: 'policy';
+} | {
+    settledBy: 'policy';
+} | Record<never, never>;
 export interface ToolApprovalFrameOutcome {
     decision: ToolApprovalRespondDecision | 'unresolved';
     ack?: ToolApprovalRespondAckView;
@@ -248,6 +261,7 @@ export interface ToolApprovalFrameOutcome {
     denyReason?: string;
     denyAttributionRefusal?: DenyAttributionRefusalDetail;
     denyAttributionDropped?: true;
+    denyAttributionRenamed?: true;
 }
 interface ToolApprovalRespondRefusalFields {
     status?: number;
@@ -265,11 +279,12 @@ export declare function readToolApprovalRespondRefusal(err: unknown): ToolApprov
 export declare function isToolApprovalFrame(ev: unknown): ev is ToolApprovalFrame;
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOffer[] | undefined;
-export declare function readRuleOfferSupply(offers: unknown, legacy: unknown): RuleOffer[] | undefined;
+export declare function readRuleOfferSupply(offers: unknown): RuleOffer[] | undefined;
 export interface ToolApprovalFrameLaneOpts {
     approvalDecisionNoteCapable?: boolean;
     respondFreeFormRulesCapable?: boolean;
     respondBatchRuleOffersCapable?: boolean;
+    approvalDecidedBy?: ApprovalDecidedByReading | undefined;
     windowIsCurrent?: boolean;
     argsUnavailable?: true;
 }

package/dist/hitl/toolApprovalWire.js

@@ -1,7 +1,7 @@
 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 { readOwnDataValue, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPair } from './askClassPair.js';
 import { legacyShadowedRuleTextOf, readAllowRuleShadowFromWire } from './allowRuleShadow.js';
 import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
@@ -10,6 +10,7 @@ import { observeCancelByDeny, surfaceRememberNotApplied, surfaceEditNotForwarded
 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';
@@ -170,6 +171,7 @@ function isParkRowInputSizeMarker(v) {
     return o.truncated === true && typeof o.bytes === 'number' && Number.isFinite(o.bytes) && o.bytes >= 0;
 }
 export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signal, parkGatedCallId) {
+    const decidedByReading = decidedByReadingSnapshotOf(deps);
     const 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)
         return { kind: 'failed', stage: 'fetch', reason: found.reason, ...(found.code !== undefined ? { code: found.code } : {}) };
@@ -190,7 +192,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
     }
     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');
@@ -295,31 +297,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 +358,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 +388,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 +412,9 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'args',
     'argsOmitted',
     'governanceForced',
-    'ruleSuggestions',
     'ruleOffers',
     'ruleOffersAbsence',
     'denialLimitFallback',
-    'ruleStoreUnreadable',
     'readRootCandidate',
     'mandated',
     'mandate',
@@ -400,6 +428,9 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'probeCause',
     'probeReason',
     'rememberRefused',
+    'boundGrantDigest',
+    'boundGrants',
+    'classifierNoRuling',
     'ruleEvidence',
     'requiresRealApproval',
     'expiresInMs',
@@ -550,13 +581,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 +857,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 +882,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 +907,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 +965,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 +994,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 +1026,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 +1048,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 +1058,48 @@ 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 parsed = readToolApprovalRespondAck(raw);
         let ack = parsed;
@@ -1077,8 +1155,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 +1172,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';

package/dist/inheritEnvWire.d.ts

@@ -1,8 +1,5 @@
 import { type InheritEnvWord, type TaskRequestLike } from './request/taskRequest.js';
-export declare const INHERIT_ENV_MIN_SERVER: readonly [number, number, number];
-export type InheritEnvServerSupport = 'supported' | 'unsupported' | 'unknown';
-export declare function inheritEnvServerSupport(version: string | undefined): InheritEnvServerSupport;
-export type InheritEnvWithheldCause = 'server_version_unknown' | 'server_too_old';
+export type InheritEnvWithheldCause = 'server_version_unknown';
 export interface InheritEnvWithheld {
     readonly cause: InheritEnvWithheldCause;
     readonly word: InheritEnvWord;

package/dist/inheritEnvWire.js

@@ -1,20 +1,6 @@
 import { INHERIT_ENV_WORDS, isInheritEnvWord } from './request/taskRequest.js';
 import { settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
 import { engineVersionTier } from './supportFloor.js';
-export const INHERIT_ENV_MIN_SERVER = Object.freeze([7, 106, 0]);
-export function inheritEnvServerSupport(version) {
-    const mm = typeof version === 'string' ? /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(version) : null;
-    if (!mm)
-        return 'unknown';
-    const got = [Number(mm[1]), Number(mm[2]), Number(mm[3])];
-    for (let i = 0; i < 3; i++) {
-        const g = got[i];
-        const need = INHERIT_ENV_MIN_SERVER[i];
-        if (g !== need)
-            return g > need ? 'supported' : 'unsupported';
-    }
-    return 'supported';
-}
 const EMPTY_DECLARATION = Object.freeze({ field: Object.freeze({}) });
 export function inheritEnvDeclaration(word, serverVersion) {
     if (word === undefined || word === null)
@@ -27,10 +13,6 @@ export function inheritEnvDeclaration(word, serverVersion) {
     return Object.freeze({ field: Object.freeze({}), withheld: Object.freeze({ cause: 'server_version_unknown', word }) });
 }
 const WITHHELD_NOTICES = Object.freeze({
-    server_too_old: Object.freeze({
-        all: "Not sent with this request: this engine is too old to accept the setting that lets the shell inherit this machine's whole environment, so this run's shell gets the default environment, with credential-like variables removed.",
-        scrub: 'Not sent with this request: this engine is too old to accept the default-environment setting, so it was left out; that has the same effect, because the default environment (credential-like variables removed) is what this run gets anyway.',
-    }),
     server_version_unknown: Object.freeze({
         all: "Not sent with this request: the engine's version is not known yet, and an engine that does not know the setting that lets the shell inherit this machine's whole environment refuses the whole request, so it was held back; this run's shell gets the default environment, with credential-like variables removed, and on an engine that does know the setting, leaving it out also clears an earlier whole-environment choice for this session.",
         scrub: "Not sent with this request: the engine's version is not known yet, so the default-environment setting was left out; that has the same effect, because leaving it out also gives this run the default environment (credential-like variables removed).",