@sema-agent/client-core 0.85.2 → 0.87.0

package/dist/hitl/sessionPolicyWire.js

@@ -1,6 +1,8 @@
 import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { hostLog } from '../host.js';
 import { isEngineRefusedToolName } from './sessionPolicyDeliverable.js';
+import { RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
+import { RULES_LEGACY_TOOL_NAME, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { rosterMountedNames } from './rosterMountedNames.js';
 const RULE_FIELD_PRESENCE = {
     toolAllow: true,
@@ -12,9 +14,19 @@ const RULE_FIELD_PRESENCE = {
 export const SESSION_POLICY_RULE_FIELDS = Object.freeze(Object.keys(RULE_FIELD_PRESENCE));
 const MAX_RULE_ENTRIES = 10_000;
 export function classifySessionPolicyFailure(e) {
-    const { status, errorCode, message } = wireFailureShapeOf(e);
+    const { status, errorCode, message, bodyField, bodyName } = wireFailureShapeOf(e);
     if (errorCode === undefined || errorCode === '')
         return { kind: 'no-verdict', message };
+    if (errorCode === RULES_LEGACY_TOOL_NAME) {
+        return {
+            kind: 'legacy-tool-name',
+            message,
+            ...(bodyField === 'toolDeny' || bodyField === 'toolAllow' ? { field: bodyField } : {}),
+            ...(bodyName !== undefined && bodyName !== '' ? { name: bodyName } : {}),
+        };
+    }
+    if (isRulesRefusalCode(errorCode) && status !== undefined && status >= 400 && status < 500)
+        return { kind: 'error', message };
     if (status === 501 || errorCode === 'capability.session_store_required') {
         return { kind: 'face-unavailable', message };
     }
@@ -209,10 +221,30 @@ function unknownFrom(failure, leg) {
             return { kind: 'unknown', why: leg === 'read' ? 'read_failed' : 'write_indeterminate', message };
         case 'loosen-forbidden':
         case 'cas-conflict':
+        case 'legacy-tool-name':
         case 'error':
             return { kind: 'unknown', why: leg === 'read' ? 'read_failed' : 'write_refused', message };
     }
 }
+function legacyToolNameOutcome(failure, prior, add) {
+    const { field, name } = failure;
+    let alreadyInRecord;
+    if (field !== undefined && name !== undefined) {
+        const inPrior = Object.hasOwn(prior, field) ? prior[field] : undefined;
+        const inAdd = Object.hasOwn(add, field) ? add[field] : undefined;
+        if (inPrior !== undefined && inPrior.includes(name))
+            alreadyInRecord = true;
+        else if (inAdd !== undefined && inAdd.includes(name))
+            alreadyInRecord = false;
+    }
+    return {
+        kind: 'legacy_tool_name',
+        message: failure.message,
+        ...(field !== undefined ? { field } : {}),
+        ...(name !== undefined ? { name } : {}),
+        ...(alreadyInRecord !== undefined ? { alreadyInRecord } : {}),
+    };
+}
 async function attemptTighten(facade, req, opts) {
     const read = await readSessionPolicy(facade, req.sessionId, opts);
     if (read.kind === 'failed')
@@ -231,6 +263,8 @@ async function attemptTighten(facade, req, opts) {
             return { done: { kind: 'loosen_forbidden', message: failure.message } };
         if (failure.kind === 'cas-conflict')
             return { retryAtRev: read.rev };
+        if (failure.kind === 'legacy-tool-name')
+            return { done: legacyToolNameOutcome(failure, read.rules, req.add) };
         return { done: unknownFrom(failure, 'write') };
     }
     let narrowed;
@@ -279,6 +313,8 @@ export function sessionPolicyTightenNotice(outcome) {
             return outcome.why === 'absent'
                 ? 'This deployment does not keep per-session tool rules, so there is nothing to tighten here.'
                 : 'This engine does not say whether it keeps per-session tool rules — it predates that answer — so the tightening entry stays hidden rather than being written blind.';
+        case 'legacy_tool_name':
+            return RULES_LEGACY_TOOL_NAME_WRITE_NOTE;
         case 'unknown':
             switch (outcome.why) {
                 case 'face_unavailable':
@@ -382,6 +418,16 @@ async function attemptRemoval(facade, sessionId, mounted, opts) {
             return { done: { kind: 'loosen_forbidden', message: failure.message, refused: removed } };
         if (failure.kind === 'cas-conflict')
             return { retryAtRev: read.rev };
+        if (failure.kind === 'legacy-tool-name') {
+            return {
+                done: {
+                    kind: 'legacy_tool_name',
+                    message: failure.message,
+                    ...(failure.field !== undefined ? { field: failure.field } : {}),
+                    ...(failure.name !== undefined ? { name: failure.name } : {}),
+                },
+            };
+        }
         return { done: removalFailed(failure, 'write') };
     }
     let narrowed;
@@ -475,6 +521,8 @@ export function sessionPolicyRemovalNotice(outcome) {
             }
         case 'write_unconfirmed':
             return 'The removal was sent but no clear answer came back from the engine — it may already be in effect. Run the removal again: it re-reads the record, and reports nothing left to remove if it did take effect.';
+        case 'legacy_tool_name':
+            return 'Nothing was changed: the engine refused to write this session’s rule record back, because an entry this removal keeps is a name the engine no longer accepts in that record (the engine\'s own error text names the entry). The removal keeps it on purpose — the supplied roster mounts a tool by exactly that name, or this version does not yet recognise the name as one the engine refuses. While the record holds that entry it cannot be written, so the entries this removal meant to take out stay in it as well.';
         default:
             return generic;
     }

package/dist/hitl/suspendedReopen.d.ts

@@ -7,3 +7,10 @@ export type SuspendedReopenReading = {
     readonly kind: 'unstated';
 };
 export declare function suspendedReopenOf(ev: unknown): SuspendedReopenReading;
+export interface ResumeReopenDetail {
+    code: string;
+    reason: 'env_failed' | 'tool_unavailable' | 'tool_contract_mismatch';
+    retriable: true;
+}
+export declare function resumeReopenFromError(err: unknown): ResumeReopenDetail | null;
+export declare function resumeReopenContent(detail: ResumeReopenDetail): string;

package/dist/hitl/suspendedReopen.js

@@ -1,13 +1,44 @@
+import { RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE } from '../engineErrorCodes.js';
 const UNSTATED = Object.freeze({ kind: 'unstated' });
 const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
 export function suspendedReopenOf(ev) {
-    if (ev === null || typeof ev !== 'object' || Array.isArray(ev))
+    if (ev === null || typeof ev !== 'object')
         return UNSTATED;
-    const o = ev;
-    if (!Object.hasOwn(o, 'reopened'))
+    try {
+        if (Array.isArray(ev))
+            return UNSTATED;
+        const o = ev;
+        if (!Object.hasOwn(o, 'reopened'))
+            return UNSTATED;
+        const v = o.reopened;
+        if (v === null)
+            return NOT_REOPENED;
+        return typeof v === 'string' && v.length > 0 ? { kind: 'reopened', code: v } : UNSTATED;
+    }
+    catch {
         return UNSTATED;
-    const v = o.reopened;
-    if (v === null)
-        return NOT_REOPENED;
-    return typeof v === 'string' && v.length > 0 ? { kind: 'reopened', code: v } : UNSTATED;
+    }
+}
+export function resumeReopenFromError(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    const code = err.errorCode;
+    if (typeof code !== 'string' || !RESUME_REOPEN_CODES.includes(code))
+        return null;
+    if (err.retriable !== true)
+        return null;
+    const reason = code.slice('resume.'.length);
+    return { code, reason, retriable: true };
+}
+export function resumeReopenContent(detail) {
+    const first = detail.code === RESUME_ENV_FAILED
+        ? 'The execution environment for this parked work could not be brought back'
+        : detail.code === RESUME_TOOL_UNAVAILABLE
+            ? 'The tool this approval was granted for is not available on this engine'
+            : 'The tool this approval was granted for has changed since the approval was recorded';
+    return [
+        first,
+        'The engine re-parked the work before consuming anything — the approval is still pending and your decision was not consumed',
+        'Re-fetch the pending approvals and decide again on an engine where the same tool is available',
+    ].join(' · ');
 }

package/dist/hitl/toolApprovalWire.js

@@ -1,4 +1,4 @@
-import { DEFAULT_DENY_REASON, DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, denyReasonForWire, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
+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';
@@ -120,10 +120,9 @@ function cardPortMissReason() {
     const otherKeysInstalled = cardPortByKey
         .keys()
         .some((k) => k !== DEFAULT_SESSION_KEY && cardPortByKey.get(k) != null);
-    if (otherKeysInstalled) {
-        return 'no approval card port installed for the default session key, but a non-default sessionKey has one — likely a keyed-install/default-read mismatch (installApprovalCardPortFor vs the zero-arg default-key read), not a missing install';
-    }
-    return 'no approval card port installed (print/non-REPL mode, or host forgot installApprovalCardPort)';
+    if (otherKeysInstalled)
+        return APPROVAL_CARD_PORT_KEY_MISMATCH_REASON;
+    return NO_APPROVAL_CARD_PORT_REASON;
 }
 function rememberRefusedByServer(e) {
     switch (readWireErrorCode(e)) {

package/dist/index.d.ts

@@ -72,7 +72,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, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, 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, GATE_PARKED_ERROR_CODE, isConfigRefusalCode, isCorruptSessionCode, isDecideParkMovedCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, 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, 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, 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, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, 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, 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, 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, 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, } from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
@@ -90,6 +90,8 @@ export * from './rewindWireCaps.js';
 export * from './rewindArchiveCapability.js';
 export * from './fileHistoryCaptureCapability.js';
 export * from './sealedKeyCapability.js';
+export * from './storePostureCapability.js';
+export * from './centerWiringCapability.js';
 export * from './registryQuotaUsage.js';
 export * from './selfOrchestrationWireCaps.js';
 export * from './skillsWireCaps.js';
@@ -143,8 +145,10 @@ export * from './principalWire.js';
 export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
+export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
+export * from './inheritEnvWire.js';
 export * from './decideReceipt.js';
 export * from './sessionMap.js';
 export * from './detachWire.js';
@@ -189,6 +193,7 @@ export * from './request/printNotification.js';
 export * from './seatContract.js';
 export * from './agentSession/contract.js';
 export * from './agentSession/backgroundView.js';
+export { READ_CREDENTIAL_NOT_ACCEPTED_NOTICE } from './readCredentialRefusal.js';
 export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from './agentSession/engineAgentRegistryRead.js';
 export type { EngineAgentRegistryClient } from './agentSession/engineAgentRegistryRead.js';
 export { stopEngineSessionBackground, engineSessionBackgroundReceiptReadingOf, ENGINE_SESSION_BACKGROUND_RECEIPT_STATES, } from './agentSession/engineSessionBackgroundStop.js';

package/dist/index.js

@@ -65,7 +65,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, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, 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, GATE_PARKED_ERROR_CODE, isConfigRefusalCode, isCorruptSessionCode, isDecideParkMovedCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, 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, 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, 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, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, 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, 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, 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, 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';
@@ -82,6 +82,8 @@ export * from './rewindWireCaps.js';
 export * from './rewindArchiveCapability.js';
 export * from './fileHistoryCaptureCapability.js';
 export * from './sealedKeyCapability.js';
+export * from './storePostureCapability.js';
+export * from './centerWiringCapability.js';
 export * from './registryQuotaUsage.js';
 export * from './selfOrchestrationWireCaps.js';
 export * from './skillsWireCaps.js';
@@ -131,8 +133,10 @@ export * from './principalWire.js';
 export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
+export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
+export * from './inheritEnvWire.js';
 export * from './decideReceipt.js';
 export * from './sessionMap.js';
 export * from './detachWire.js';
@@ -175,6 +179,7 @@ export * from './request/printNotification.js';
 export * from './seatContract.js';
 export * from './agentSession/contract.js';
 export * from './agentSession/backgroundView.js';
+export { READ_CREDENTIAL_NOT_ACCEPTED_NOTICE } from './readCredentialRefusal.js';
 export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from './agentSession/engineAgentRegistryRead.js';
 export { stopEngineSessionBackground, engineSessionBackgroundReceiptReadingOf, ENGINE_SESSION_BACKGROUND_RECEIPT_STATES, } from './agentSession/engineSessionBackgroundStop.js';
 export * from './model/catalog.js';

package/dist/inheritEnvWire.d.ts

@@ -0,0 +1,22 @@
+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 interface InheritEnvWithheld {
+    readonly cause: InheritEnvWithheldCause;
+    readonly word: InheritEnvWord;
+}
+export interface InheritEnvDeclaration {
+    readonly field: {
+        readonly inheritEnv?: InheritEnvWord;
+    };
+    readonly withheld?: InheritEnvWithheld;
+}
+export declare function inheritEnvDeclaration(word: unknown, serverVersion: string | undefined): InheritEnvDeclaration;
+export declare function inheritEnvWithheldNotice(withheld: InheritEnvWithheld): string;
+export interface InheritEnvRefusalDetail {
+    readonly code: string;
+}
+export declare function inheritEnvRefusalFromError(err: unknown, sentRequest: TaskRequestLike | undefined): InheritEnvRefusalDetail | null;
+export declare function inheritEnvRefusalContent(_detail: InheritEnvRefusalDetail): string;

package/dist/inheritEnvWire.js

@@ -0,0 +1,84 @@
+import { INHERIT_ENV_WORDS, isInheritEnvWord } from './request/taskRequest.js';
+import { settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.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)
+        return EMPTY_DECLARATION;
+    if (!isInheritEnvWord(word)) {
+        throw new TypeError(`inheritEnvDeclaration: inheritEnv 只接受 ${INHERIT_ENV_WORDS.map((w) => `'${w}'`).join(' / ')} 或缺席 —— 收到 ${Array.isArray(word) ? 'typeof=object / array' : `typeof=${typeof word}`}。坏词在版本判定之前就拒:「这一次不发」不许顺手吞掉一个打错字的声明。错误文本只报形状,不回显值。`);
+    }
+    const support = inheritEnvServerSupport(serverVersion);
+    if (support === 'supported')
+        return Object.freeze({ field: Object.freeze({ inheritEnv: word }) });
+    const cause = support === 'unsupported' ? 'server_too_old' : 'server_version_unknown';
+    return Object.freeze({ field: Object.freeze({}), withheld: Object.freeze({ cause, 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).",
+    }),
+});
+const WITHHELD_UNKNOWN_NOTICE = 'Not sent with this request: the shell-environment setting was held back for a reason this version does not recognize.';
+export function inheritEnvWithheldNotice(withheld) {
+    try {
+        if (typeof withheld !== 'object' || withheld === null)
+            return WITHHELD_UNKNOWN_NOTICE;
+        const cause = withheld.cause;
+        const word = withheld.word;
+        if (typeof cause !== 'string' || !Object.hasOwn(WITHHELD_NOTICES, cause) || !isInheritEnvWord(word))
+            return WITHHELD_UNKNOWN_NOTICE;
+        return WITHHELD_NOTICES[cause][word];
+    }
+    catch {
+        return WITHHELD_UNKNOWN_NOTICE;
+    }
+}
+const FIELD_INVALID = 'request.field_invalid';
+function readGuarded(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return undefined;
+    try {
+        return o[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function inheritEnvRefusalFromError(err, sentRequest) {
+    try {
+        if (readGuarded(sentRequest, 'inheritEnv') !== 'all')
+            return null;
+        if (readGuarded(err, 'errorCode') !== FIELD_INVALID)
+            return null;
+        if (settingsPermissionBucketRefusalFromError(err) !== null)
+            return null;
+        return Object.freeze({ code: FIELD_INVALID });
+    }
+    catch {
+        return null;
+    }
+}
+const REFUSAL_NOT_ACCEPTED = 'The engine refused this request as invalid without naming the field · ' +
+    "This request asked for the shell to inherit this machine's whole environment, which the engine accepts only when tools run directly on its own machine and the request belongs to a session; if that is what it refused, send it again without that setting (or with the default)";
+export function inheritEnvRefusalContent(_detail) {
+    return REFUSAL_NOT_ACCEPTED;
+}

package/dist/peerFrames.js

@@ -1,4 +1,5 @@
 import { applyDisplayFace, LEGACY_NAME_FACE } from './displayUntrusted.js';
+import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS } from './generated/engineFactTables.js';
 const WIRE_KEY_FROM = 'from';
 const WIRE_KEY_BODY = 'body';
 const WIRE_KEY_KIND = 'kind';
@@ -107,16 +108,7 @@ export function classifyPeerNotification(n) {
     }
     return null;
 }
-const AUTHORITY_ENVELOPE_TAGS = Object.freeze([
-    'system-reminder',
-    'task-notification',
-    'new-diagnostics',
-    'user_memory',
-    'scope',
-    'skills',
-    'total_tokens',
-    'instruction-files',
-]);
+const AUTHORITY_ENVELOPE_TAGS = CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS;
 const ZWSP = String.fromCharCode(0x200b);
 const AUTHORITY_BREAKOUT_RE = new RegExp(`<\\s*\\/?\\s*(?:${AUTHORITY_ENVELOPE_TAGS.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})(?:\\s[^>]*)?>`, 'gi');
 function neutralizeAuthorityTags(text) {

package/dist/printInitToolFace.d.ts

@@ -28,6 +28,12 @@ export declare function printInitRosterSignal(message: SDKMessage): PrintInitRos
 export declare function decidePrintInitToolFace(signal: Exclude<PrintInitRosterSignal, {
     kind: 'pending';
 }>, fallback: LiveInitToolFace | null): PrintInitToolFace | null;
+export type PrintInitToolsSource = 'engine-roster' | 'estimate' | 'host-static';
+export interface PrintInitToolFaceSupersetKeys {
+    _sema_tools_source: PrintInitToolsSource;
+    _sema_tools_fallback_reason?: PrintInitRosterFallbackReason;
+}
+export declare function printInitToolFaceSupersetKeys(face: PrintInitToolFace | null): PrintInitToolFaceSupersetKeys;
 export declare function printInitToolFaceDebugLine(face: PrintInitToolFace | null): string;
 export type PrintInitGateStep = {
     kind: 'hold';

package/dist/printInitToolFace.js

@@ -36,8 +36,9 @@ export function decidePrintInitToolFace(signal, fallback) {
     const tools = fallback === null ? undefined : fallback.tools;
     if (fallback === null || !Array.isArray(tools))
         return null;
+    const assembly = fallback.source;
     return {
-        source: fallback.source,
+        source: assembly === 'scenario-probe' ? 'scenario-probe' : 'wire-vocabulary',
         tools: tools.flatMap((t) => {
             const name = typeof t === 'object' && t !== null ? t.name : undefined;
             return typeof name === 'string' ? [{ name }] : [];
@@ -45,6 +46,116 @@ export function decidePrintInitToolFace(signal, fallback) {
         fallbackReason: signal.reason,
     };
 }
+const TOOLS_SOURCE_KEY = '_sema_tools_source';
+const TOOLS_FALLBACK_REASON_KEY = '_sema_tools_fallback_reason';
+const FALLBACK_REASONS = ['manifest-without-roster', 'model-activity-first', 'run-ended', 'wait-timeout'];
+export function printInitToolFaceSupersetKeys(face) {
+    const f = face;
+    if (typeof f !== 'object' || f === null)
+        return { _sema_tools_source: 'host-static' };
+    let source;
+    try {
+        source = f.source;
+    }
+    catch {
+        source = undefined;
+    }
+    let reason;
+    let reasonRead = true;
+    try {
+        reason = f.fallbackReason;
+    }
+    catch {
+        reason = undefined;
+        reasonRead = false;
+    }
+    if (source === 'engine-roster' && reasonRead && reason === undefined)
+        return { _sema_tools_source: 'engine-roster' };
+    return typeof reason === 'string' && FALLBACK_REASONS.includes(reason)
+        ? { _sema_tools_source: 'estimate', _sema_tools_fallback_reason: reason }
+        : { _sema_tools_source: 'estimate' };
+}
+const PROTO_WALK_MAX = 64;
+function snapshotStampKeys(rec) {
+    try {
+        const saved = [];
+        for (const key of [TOOLS_SOURCE_KEY, TOOLS_FALLBACK_REASON_KEY]) {
+            let own;
+            let o = rec;
+            for (let depth = 0; o !== null; depth++) {
+                if (depth >= PROTO_WALK_MAX)
+                    return undefined;
+                const d = Reflect.getOwnPropertyDescriptor(o, key);
+                if (d !== undefined) {
+                    if ('get' in d || 'set' in d)
+                        return undefined;
+                    if (depth === 0)
+                        own = d;
+                    break;
+                }
+                o = Reflect.getPrototypeOf(o);
+            }
+            saved.push({ key, own });
+        }
+        return { keys: saved, extensible: Reflect.isExtensible(rec) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function restoreStampKeys(rec, saved) {
+    let clean = true;
+    for (const s of saved) {
+        try {
+            const now = Reflect.getOwnPropertyDescriptor(rec, s.key);
+            let ok = true;
+            if (s.own !== undefined) {
+                if (now === undefined)
+                    ok = Reflect.defineProperty(rec, s.key, s.own);
+                else if (!('value' in now) || !Object.is(now.value, s.own.value))
+                    ok = Reflect.set(rec, s.key, s.own.value);
+            }
+            else if (now !== undefined) {
+                ok = Reflect.deleteProperty(rec, s.key);
+            }
+            if (!ok)
+                clean = false;
+        }
+        catch {
+            clean = false;
+        }
+    }
+    return clean;
+}
+function stampPrintInitToolFaceKeys(frame, face) {
+    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+        return;
+    const keys = printInitToolFaceSupersetKeys(face);
+    const rec = frame;
+    const snap = snapshotStampKeys(rec);
+    if (snap === undefined)
+        return;
+    const saved = snap.keys;
+    const hadSource = saved[0]?.own !== undefined;
+    const hadReason = saved[1]?.own !== undefined;
+    const reason = keys._sema_tools_fallback_reason;
+    if (!snap.extensible && (!hadSource || (reason !== undefined && !hadReason)))
+        return;
+    const writeSource = () => Reflect.set(rec, TOOLS_SOURCE_KEY, keys._sema_tools_source);
+    const writeReason = () => reason !== undefined ? Reflect.set(rec, TOOLS_FALLBACK_REASON_KEY, reason) : !hadReason || Reflect.deleteProperty(rec, TOOLS_FALLBACK_REASON_KEY);
+    const steps = reason === undefined && hadReason && !hadSource ? [writeReason, writeSource] : [writeSource, writeReason];
+    try {
+        for (const step of steps) {
+            if (!step()) {
+                restoreStampKeys(rec, saved);
+                return;
+            }
+        }
+    }
+    catch {
+        restoreStampKeys(rec, saved);
+    }
+}
 export function printInitToolFaceDebugLine(face) {
     if (face === null) {
         return "init tools: the host's static list — no tool roster arrived and no estimate was available";
@@ -121,7 +232,9 @@ export async function* withPrintInitFrame(source, opts) {
         }
         catch {
         }
-        yield await opts.buildInit(step.face);
+        const init = await opts.buildInit(step.face);
+        stampPrintInitToolFaceKeys(init, step.face);
+        yield init;
         for (const m of step.messages)
             yield m;
     };

package/dist/readCredentialRefusal.d.ts

@@ -0,0 +1,2 @@
+export declare function isReadCredentialRefusal(e: unknown): boolean;
+export declare const READ_CREDENTIAL_NOT_ACCEPTED_NOTICE = "This engine requires a credential to show this, and this client did not present one it accepts.";

package/dist/readCredentialRefusal.js

@@ -0,0 +1,7 @@
+import { wireFailureShapeOf } from './wireFailureShape.js';
+const AUTH_UNAUTHORIZED = 'auth.unauthorized';
+export function isReadCredentialRefusal(e) {
+    const { status, errorCode } = wireFailureShapeOf(e);
+    return status === 401 && (errorCode === undefined || errorCode === '' || errorCode === AUTH_UNAUTHORIZED);
+}
+export const READ_CREDENTIAL_NOT_ACCEPTED_NOTICE = 'This engine requires a credential to show this, and this client did not present one it accepts.';

package/dist/request/taskRequest.d.ts

@@ -48,8 +48,8 @@ export interface TaskRequestInput {
     maxThinkingTokens?: number;
     memoryCapture?: 'off';
     memory?: 'off';
-    approverPosture?: NonNullable<TaskRequest['approverPosture']>;
     fileHistory?: 'disabled';
+    inheritEnv?: InheritEnvWord;
     rewind?: Record<string, unknown>;
     repo?: string;
     council?: boolean;
@@ -101,11 +101,10 @@ export declare const MEMORY_OFF: "off";
 export declare function memoryOffDeclarationField(declared: boolean): {
     memory: 'off';
 } | Record<string, never>;
-export declare const APPROVER_POSTURE_BYPASS: "bypass";
-export declare function approverPostureDeclarationField(declared: boolean): {
-    approverPosture: 'bypass';
-} | Record<string, never>;
 export declare const FILE_HISTORY_DISABLED: "disabled";
+export declare const INHERIT_ENV_WORDS: readonly ["all", "scrub"];
+export type InheritEnvWord = (typeof INHERIT_ENV_WORDS)[number];
+export declare function isInheritEnvWord(v: unknown): v is InheritEnvWord;
 export declare function memoryOffDeclared(input: {
     flag?: unknown;
     settingsMemory?: unknown;