@sema-agent/client-core 0.111.0 → 0.112.0

package/dist/generated/settingsSchemaHooksClassifier.js

@@ -1,13 +1,27 @@
 export const SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE = (HOOK_EVENTS) => {
     const HOOK_GUARD_EVENTS = ["PreToolUse", "PermissionRequest"];
     const HOOK_SHELLS = ["bash", "powershell"];
-    const HOOK_ENTRY_COMMON_FIELDS = { if: "string?", timeout: "seconds?", statusMessage: "string?", once: "boolean?" };
-    const HOOK_ENTRY_FIELDS = {
-        command: { command: "text", shell: "shell?", async: "boolean?", asyncRewake: "boolean?", ...HOOK_ENTRY_COMMON_FIELDS },
-        prompt: { prompt: "text", model: "string?", ...HOOK_ENTRY_COMMON_FIELDS },
-        agent: { prompt: "text", model: "string?", ...HOOK_ENTRY_COMMON_FIELDS },
-        http: { url: "text", headers: "stringRecord?", allowedEnvVars: "stringList?", ...HOOK_ENTRY_COMMON_FIELDS },
-        mcp_tool: { server: "string", tool: "string", input: "record?", ...HOOK_ENTRY_COMMON_FIELDS },
+    const HOOK_ON_FAILURE_ACCEPTED = { continue: true, block: true };
+    const HOOK_ENTRY_FIELDS_READ = {
+        command: {
+            command: "text",
+            args: "argv?",
+            shell: "shell?",
+            async: "boolean?",
+            asyncRewake: "boolean?",
+            onFailure: "onFailure?",
+            if: "string?",
+            timeout: "seconds?",
+            statusMessage: "string?",
+            once: "boolean?",
+            rewakeMessage: "nonEmpty?",
+            rewakeSummary: "nonEmpty?",
+            cloud: "any?",
+        },
+        prompt: { prompt: "text", model: "string?", if: "string?", timeout: "seconds?", statusMessage: "string?", once: "boolean?", continueOnBlock: "boolean?" },
+        agent: { prompt: "text", model: "string?", if: "string?", timeout: "seconds?", statusMessage: "string?", once: "boolean?" },
+        http: { url: "text", headers: "stringRecord?", allowedEnvVars: "stringList?", onFailure: "onFailure?", if: "string?", timeout: "seconds?", statusMessage: "string?", once: "boolean?", cloud: "any?" },
+        mcp_tool: { server: "string", tool: "string", input: "record?", if: "string?", timeout: "seconds?", statusMessage: "string?", once: "boolean?" },
     };
     function hookShapeOf(v) {
         try {
@@ -146,6 +160,8 @@ export const SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE = (HOOK_EVENTS) => {
         switch (base) {
             case "text":
                 return typeof value === "string" && value.length > 0 && !value.includes("\0");
+            case "nonEmpty":
+                return typeof value === "string" && value.length > 0;
             case "string":
                 return typeof value === "string";
             case "shell":
@@ -163,6 +179,19 @@ export const SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE = (HOOK_EVENTS) => {
                     if (typeof value[i] !== "string")
                         return false;
                 return true;
+            case "argv":
+                if (!hookIsArray(value))
+                    return false;
+                for (let i = 0; i < value.length; i++) {
+                    const arg = value[i];
+                    if (typeof arg !== "string" || arg.includes("\0"))
+                        return false;
+                }
+                return true;
+            case "onFailure":
+                return typeof value === "string" && Object.hasOwn(HOOK_ON_FAILURE_ACCEPTED, value);
+            case "any":
+                return true;
             case "record":
                 return hookIsRecord(value);
             default: {
@@ -175,9 +204,9 @@ export const SETTINGS_CLASSIFY_HOOKS_CONFIG_CLOSURE = (HOOK_EVENTS) => {
         if (!hookIsRecord(entry))
             return {};
         const type = Object.hasOwn(entry, "type") ? entry.type : undefined;
-        if (typeof type !== "string" || !Object.hasOwn(HOOK_ENTRY_FIELDS, type))
+        if (typeof type !== "string" || !Object.hasOwn(HOOK_ENTRY_FIELDS_READ, type))
             return { field: "type" };
-        const fields = HOOK_ENTRY_FIELDS[type];
+        const fields = HOOK_ENTRY_FIELDS_READ[type];
         const out = { type };
         for (const field of Object.keys(fields)) {
             const kind = fields[field];

package/dist/generated/settingsSchemaTables.d.ts

@@ -1,6 +1,7 @@
 export declare const SETTINGS_ENGINE_OWNED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit"];
 export declare const SETTINGS_SECRET_LITERAL_RE: RegExp;
 export declare const SETTINGS_PRIVATE_KEY_PEM_HEADER: RegExp;
+export declare const SETTINGS_SHA256_DIGEST_RE: RegExp;
 export declare const SETTINGS_DEVICE_CODE_TTL_SECONDS = 900;
 export declare const SETTINGS_DEVICE_POLL_INTERVAL_SECONDS = 5;
 export declare const SETTINGS_TIER_GROUP_NAME_RE: RegExp;
@@ -19,3 +20,54 @@ export declare const SETTINGS_WEB_ADMIN_TOKEN_ENV: Readonly<{
     readonly tokenFile: "SEMA_WEB_ADMIN_TOKEN_FILE";
 }>;
 export declare const SETTINGS_NO_EXECUTION_TARGET_LANES: readonly ["none"];
+export declare const SETTINGS_ROOT_DOCUMENT_UNREADABLE_REASONS: readonly ["bad_json", "bad_shape", "io"];
+export declare const SETTINGS_UNIT_PLACES: Readonly<{
+    permissions: Readonly<{
+        path: readonly ["permissions"];
+        category: "permissions";
+    }>;
+    permissionMode: Readonly<{
+        path: readonly ["permissions", "defaultMode"];
+        category: "permissionMode";
+        reading: "permissionMode";
+    }>;
+    additionalDirectories: Readonly<{
+        path: readonly ["permissions", "additionalDirectories"];
+        category: "sandboxNetwork";
+        reading: "stringList";
+    }>;
+    sandbox: Readonly<{
+        path: readonly ["sandbox"];
+        category: "sandboxNetwork";
+    }>;
+    disableBypassPermissionsMode: Readonly<{
+        path: readonly ["permissions", "disableBypassPermissionsMode"];
+        category: "killSwitches";
+        reading: "killSwitch";
+    }>;
+    disableAutoMode: Readonly<{
+        path: readonly ["permissions", "disableAutoMode"];
+        category: "killSwitches";
+        reading: "killSwitch";
+    }>;
+    hooks: Readonly<{
+        path: readonly ["hooks"];
+        category: "hooks";
+        reading: "hooks";
+    }>;
+    env: Readonly<{
+        path: readonly ["env"];
+        category: "env";
+        reading: "envMap";
+    }>;
+    model: Readonly<{
+        path: readonly ["model"];
+        category: "model";
+        reading: "nonEmptyString";
+    }>;
+    outputStyle: Readonly<{
+        path: readonly ["outputStyle"];
+        category: "ui";
+        reading: "nonEmptyString";
+    }>;
+}>;

package/dist/generated/settingsSchemaTables.js

@@ -11,6 +11,7 @@ export const SETTINGS_ENGINE_OWNED_HOOK_EVENTS = Object.freeze([
 ]);
 export const SETTINGS_SECRET_LITERAL_RE = Object.freeze(/^(sk-|gh[opus]_|github_pat_|xox[baprse]-|xapp-|bearer\s|basic\s|eyJ[A-Za-z0-9_-]{10,}\.|AKIA[0-9A-Z]{12,}|AIza[0-9A-Za-z_-]{20,}|-----BEGIN[A-Z0-9 ]*PRIVATE KEY)/i);
 export const SETTINGS_PRIVATE_KEY_PEM_HEADER = Object.freeze(/-----BEGIN[A-Z0-9 ]*PRIVATE KEY/i);
+export const SETTINGS_SHA256_DIGEST_RE = Object.freeze(/^sha256:[0-9a-f]{64}$/);
 export const SETTINGS_DEVICE_CODE_TTL_SECONDS = 900;
 export const SETTINGS_DEVICE_POLL_INTERVAL_SECONDS = 5;
 export const SETTINGS_TIER_GROUP_NAME_RE = Object.freeze(/^[a-z0-9][a-z0-9._-]*$/i);
@@ -74,3 +75,20 @@ export const SETTINGS_WEB_ADMIN_TOKEN_ENV = Object.freeze({ token: "SEMA_WEB_ADM
 export const SETTINGS_NO_EXECUTION_TARGET_LANES = Object.freeze([
     "none",
 ]);
+export const SETTINGS_ROOT_DOCUMENT_UNREADABLE_REASONS = Object.freeze([
+    "bad_json",
+    "bad_shape",
+    "io",
+]);
+export const SETTINGS_UNIT_PLACES = Object.freeze({
+    "permissions": Object.freeze({ path: Object.freeze(["permissions"]), category: "permissions" }),
+    "permissionMode": Object.freeze({ path: Object.freeze(["permissions", "defaultMode"]), category: "permissionMode", reading: "permissionMode" }),
+    "additionalDirectories": Object.freeze({ path: Object.freeze(["permissions", "additionalDirectories"]), category: "sandboxNetwork", reading: "stringList" }),
+    "sandbox": Object.freeze({ path: Object.freeze(["sandbox"]), category: "sandboxNetwork" }),
+    "disableBypassPermissionsMode": Object.freeze({ path: Object.freeze(["permissions", "disableBypassPermissionsMode"]), category: "killSwitches", reading: "killSwitch" }),
+    "disableAutoMode": Object.freeze({ path: Object.freeze(["permissions", "disableAutoMode"]), category: "killSwitches", reading: "killSwitch" }),
+    "hooks": Object.freeze({ path: Object.freeze(["hooks"]), category: "hooks", reading: "hooks" }),
+    "env": Object.freeze({ path: Object.freeze(["env"]), category: "env", reading: "envMap" }),
+    "model": Object.freeze({ path: Object.freeze(["model"]), category: "model", reading: "nonEmptyString" }),
+    "outputStyle": Object.freeze({ path: Object.freeze(["outputStyle"]), category: "ui", reading: "nonEmptyString" }),
+});

package/dist/generated/settingsSchemaTypes.d.ts

@@ -3,35 +3,44 @@ declare const HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFa
 type HookEventWord = (typeof HOOK_EVENTS)[number];
 declare const HOOK_ENTRY_TYPES: readonly ["command", "prompt", "agent", "http", "mcp_tool"];
 export type HookEntryType = (typeof HOOK_ENTRY_TYPES)[number];
+declare const HOOK_ON_FAILURE_WORDS: readonly ["continue", "block"];
+export type HookOnFailure = (typeof HOOK_ON_FAILURE_WORDS)[number];
 declare const HOOK_SHELLS: readonly ["bash", "powershell"];
-declare const HOOK_ENTRY_FIELDS: {
-    readonly command: {
+declare const HOOK_ENTRY_FIELDS: Readonly<{
+    command: Readonly<{
+        readonly rewakeMessage: "nonEmpty?";
+        readonly rewakeSummary: "nonEmpty?";
+        readonly cloud: "any?";
         readonly if: "string?";
         readonly timeout: "seconds?";
         readonly statusMessage: "string?";
         readonly once: "boolean?";
         readonly command: "text";
+        readonly args: "argv?";
         readonly shell: "shell?";
         readonly async: "boolean?";
         readonly asyncRewake: "boolean?";
-    };
-    readonly prompt: {
+        readonly onFailure: "onFailure?";
+    }>;
+    prompt: Readonly<{
+        readonly continueOnBlock: "boolean?";
         readonly if: "string?";
         readonly timeout: "seconds?";
         readonly statusMessage: "string?";
         readonly once: "boolean?";
         readonly prompt: "text";
         readonly model: "string?";
-    };
-    readonly agent: {
+    }>;
+    agent: Readonly<{
         readonly if: "string?";
         readonly timeout: "seconds?";
         readonly statusMessage: "string?";
         readonly once: "boolean?";
         readonly prompt: "text";
         readonly model: "string?";
-    };
-    readonly http: {
+    }>;
+    http: Readonly<{
+        readonly cloud: "any?";
         readonly if: "string?";
         readonly timeout: "seconds?";
         readonly statusMessage: "string?";
@@ -39,8 +48,9 @@ declare const HOOK_ENTRY_FIELDS: {
         readonly url: "text";
         readonly headers: "stringRecord?";
         readonly allowedEnvVars: "stringList?";
-    };
-    readonly mcp_tool: {
+        readonly onFailure: "onFailure?";
+    }>;
+    mcp_tool: Readonly<{
         readonly if: "string?";
         readonly timeout: "seconds?";
         readonly statusMessage: "string?";
@@ -48,9 +58,9 @@ declare const HOOK_ENTRY_FIELDS: {
         readonly server: "string";
         readonly tool: "string";
         readonly input: "record?";
-    };
-};
-type HookFieldBaseValue<B> = B extends "text" | "string" ? string : B extends "shell" ? (typeof HOOK_SHELLS)[number] : B extends "boolean" ? boolean : B extends "seconds" ? number : B extends "stringRecord" ? Record<string, string> : B extends "stringList" ? string[] : B extends "record" ? Record<string, unknown> : never;
+    }>;
+}>;
+type HookFieldBaseValue<B> = B extends "text" | "nonEmpty" | "string" ? string : B extends "shell" ? (typeof HOOK_SHELLS)[number] : B extends "onFailure" ? HookOnFailure : B extends "any" ? unknown : B extends "boolean" ? boolean : B extends "seconds" ? number : B extends "stringRecord" ? Record<string, string> : B extends "stringList" | "argv" ? string[] : B extends "record" ? Record<string, unknown> : never;
 type HookFieldValue<K> = K extends `${infer B}?` ? HookFieldBaseValue<B> : HookFieldBaseValue<K>;
 type Flat<O> = {
     [K in keyof O]: O[K];

package/dist/generated/settingsSchemaUrlShape.d.ts

@@ -0,0 +1 @@
+export declare const SETTINGS_URL_SHAPE_CLOSURE: (isHierarchicalUrl: (raw: string) => boolean) => any;

package/dist/generated/settingsSchemaUrlShape.js

@@ -0,0 +1,17 @@
+export const SETTINGS_URL_SHAPE_CLOSURE = (isHierarchicalUrl) => {
+    const HTTP_URL_PARTS = ["userinfo", "query", "fragment"];
+    function httpUrlFlaws(raw, forbid) {
+        if (!isHierarchicalUrl(raw))
+            return ["not-http-url"];
+        const u = new URL(raw);
+        const hashAt = u.href.indexOf("#");
+        const present = {
+            userinfo: u.username !== "" || u.password !== "",
+            query: (hashAt < 0 ? u.href : u.href.slice(0, hashAt)).includes("?"),
+            fragment: hashAt >= 0,
+        };
+        const shape = u.protocol === "http:" || u.protocol === "https:" ? [] : ["not-http-url"];
+        return [...shape, ...HTTP_URL_PARTS.filter((p) => forbid.includes(p) && present[p])];
+    }
+    return { httpUrlFlaws };
+};

package/dist/hitl/decisionRefusal.d.ts

@@ -5,7 +5,9 @@ import { type ProtocolErrorName, type ProtocolErrorNameReading } from '../wireFa
 import type { DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
 import { type DeliveredReading } from './attributionLadder.js';
 import { type AnswerCapture, type UnansweredCapture } from '../engineWireFor.js';
+import { type DecisionRefusalWayOut } from '../checkpointRowVerdict.js';
 export declare const ASK_DECIDED_CODE = "conflict.ask_decided";
+export type { DecisionRefusalWayOut } from '../checkpointRowVerdict.js';
 export type DecisionRefusalStanding = 'settled-elsewhere' | 'ambiguous' | 'refused-pending';
 export type { DecisionRefusalConflict } from './decisionConflict.js';
 export { refusalCarrierOf, type RefusalCarrier } from './hitlBridge.js';
@@ -57,6 +59,7 @@ export interface DecisionRefusalReading {
     readonly conflict?: DecisionRefusalConflict;
     readonly unrecoverable?: true;
     readonly acceptableForm?: {} | null;
+    readonly wayOut?: DecisionRefusalWayOut;
 }
 export declare function mintDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext, attributionCarried?: boolean, delivered?: DeliveredReading, carried?: RefusalCarrier): DecisionRefusalReading;
 export declare function readDecisionRefusalReading(err: {} | null | undefined, context?: RefusalRouteContext): DecisionRefusalReading;
@@ -67,6 +70,7 @@ export interface DecisionRefusalClassified {
     readonly transient?: true;
     readonly conflict?: DecisionRefusalConflict;
     readonly unrecoverable?: true;
+    readonly wayOut?: DecisionRefusalWayOut;
 }
 export declare function classifyDecisionRefusal(err: unknown, context?: RefusalRouteContext): DecisionRefusalClassified | undefined;
 export declare function classifyDeliveredDecisionRefusal(err: {} | null | undefined, delivered: DeliveredReading): DecisionRefusalClassified | undefined;

package/dist/hitl/decisionRefusal.js

@@ -1,4 +1,4 @@
-import { ASK_GONE, ASK_GONE_PARKED, RESUME_CONSTRAINT_REJECTED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, isDecideRowUnrevivableCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
+import { ASK_GONE, ASK_GONE_PARKED, CORRUPT_ROW_ERROR_CODE, RESUME_CONSTRAINT_REJECTED, RESUME_PREFLIGHT_REJECTED, isDecideAlreadyResolvedCode, isDecideParkMovedCode, isDecideRowUnrevivableCode, refusalRetriableReading, refusalSaysStillPending } from '../engineErrorCodes.js';
 import { isUiLanguage } from '../env/uiLanguage.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { notPendingCauseReading, refusalCauseWordOf } from './approvalEndingCause.js';
@@ -10,6 +10,7 @@ import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
 import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorPresent, readErrorString, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
 import { attributionRefusalOf, carrierReadOf } from './attributionLadder.js';
 import { CODE_UNREADABLE, ownReadingSlot } from '../engineWireFor.js';
+import { isDecisionRefusalWayOut } from '../checkpointRowVerdict.js';
 export const ASK_DECIDED_CODE = 'conflict.ask_decided';
 const TRANSIENT_STATUSES = new Set([408, 425, 429, 502, 503, 504]);
 export { refusalCarrierOf } from './hitlBridge.js';
@@ -32,7 +33,7 @@ const ROUTE_WORDS = { approval_decide: true, live_respond: true, ask_decide: tru
 export const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
 const PRIOR_REFUSAL_EVIDENCE = Object.freeze([
     Object.freeze({
-        errorCode: 'corrupt',
+        errorCode: CORRUPT_ROW_ERROR_CODE,
         routes: Object.freeze(['plan_review', 'approval_decide', 'live_respond']),
         evidence: 'server resume-legs.ts:1019 / :2752 / :2910 (resume context read, before the claim CAS at :1666 / :1457); plan_review resumePlanReview reads context before settling',
     }),
@@ -223,10 +224,13 @@ export function mintDecisionRefusalReading(err, context, attributionCarried, del
     const conflict = inRange && status === 409 && obj !== undefined ? isolated(() => decisionConflictOf(obj, captured, pn)) : undefined;
     const unrecoverable = inRange && status !== undefined && Number.isInteger(status) && status >= 400 && status <= 599 && isDecideRowUnrevivableCode(errorCode);
     const acceptableForm = errorCode === RESUME_CONSTRAINT_REJECTED && obj !== undefined ? isolated(() => readErrorPresent(obj, 'acceptableForm')) : undefined;
+    const wayOutRaw = inRange && status === 409 && obj !== undefined ? isolated(() => readErrorString(obj, 'wayOut')) : undefined;
+    const wayOut = isDecisionRefusalWayOut(wayOutRaw) ? wayOutRaw : undefined;
     const transient = inRange &&
         conflict !== 'grant_changed' &&
         conflict !== 'row_integrity' &&
         !unrecoverable &&
+        wayOut === undefined &&
         (TRANSIENT_STATUSES.has(status) || retriable || (status === 404 && obj !== undefined && isolated(() => notPendingCauseReading(obj)) === 'other_replica'));
     return Object.freeze({
         ...(status !== undefined ? { status } : {}),
@@ -246,6 +250,7 @@ export function mintDecisionRefusalReading(err, context, attributionCarried, del
         ...(conflict !== undefined ? { conflict } : {}),
         ...(unrecoverable ? { unrecoverable: true } : {}),
         ...(acceptableForm !== undefined ? { acceptableForm } : {}),
+        ...(wayOut !== undefined ? { wayOut } : {}),
     });
 }
 export function readDecisionRefusalReading(err, context) {
@@ -264,6 +269,7 @@ function classifiedOf(reading) {
         const transient = ownDataField(reading, 'transient') === true;
         const conflict = ownDataField(reading, 'conflict');
         const unrecoverable = ownDataField(reading, 'unrecoverable') === true;
+        const wayOut = ownDataField(reading, 'wayOut');
         return Object.freeze({
             standing,
             status,
@@ -271,6 +277,7 @@ function classifiedOf(reading) {
             ...(transient ? { transient: true } : {}),
             ...(typeof conflict === 'string' ? { conflict: conflict } : {}),
             ...(unrecoverable ? { unrecoverable: true } : {}),
+            ...(isDecisionRefusalWayOut(wayOut) ? { wayOut } : {}),
         });
     }
     catch {
@@ -312,6 +319,9 @@ export function decisionRefusalClosesOut(refusal, pending) {
     const conflict = readThrownSlot(refusal, 'conflict', 'data');
     if (conflict === 'grant_changed' || conflict === THROWN_SLOT_UNREADABLE)
         return false;
+    const wayOut = readThrownSlot(refusal, 'wayOut', 'data');
+    if (wayOut === 'newer_worker' || wayOut === THROWN_SLOT_UNREADABLE)
+        return false;
     return standing === 'ambiguous' || standing === 'refused-pending';
 }
 export function decisionStatusTag(status, errorCode) {

package/dist/hitl/localAllowRedemption.d.ts

@@ -21,18 +21,21 @@ export interface LocalAllowOfferedFacts {
     readonly scopeRoot: string | undefined;
     readonly road: EngineCapState;
 }
-export type LocalAllowRedeemabilityInput = ({
-    readonly subject: 'offered';
-} & LocalAllowOfferedFacts) | {
-    readonly subject: 'declared';
+export interface LocalAllowDeclaredFacts {
     readonly source: HostSettingsLayer;
     readonly workspace: WorkspaceTrustState | 'unreadable';
     readonly managedRulesOnly: boolean | 'unreadable';
-    readonly rule: string;
     readonly scopeRoot: string | undefined;
     readonly store: ListAllPersistedRulesOutcome;
-};
+}
+export type LocalAllowRedeemabilityInput = ({
+    readonly subject: 'offered';
+} & LocalAllowOfferedFacts) | ({
+    readonly subject: 'declared';
+    readonly rule: string;
+} & LocalAllowDeclaredFacts);
 export declare function localAllowRedeemability(input: LocalAllowRedeemabilityInput): LocalAllowRedeemability;
+export declare function localAllowLandingRedeemability(rule: {} | null | undefined, landing: {} | null | undefined): LocalAllowRedeemability;
 export declare const LOCAL_ALLOW_REDEMPTION_REFUSALS: readonly ["managed_only", "no_scope_root", "rule_shape", "request_refused", "preview_mismatch", "engine_refused", "ticket_dead"];
 export type LocalAllowRedemptionRefusal = (typeof LOCAL_ALLOW_REDEMPTION_REFUSALS)[number];
 export declare const LOCAL_ALLOW_REDEMPTION_UNAVAILABLE_CAUSES: readonly ["road_closed", "road_unknown", "policy_unreadable", "input_unreadable", "prepare_failed"];

package/dist/hitl/localAllowRedemption.js

@@ -99,6 +99,26 @@ export function localAllowRedeemability(input) {
         return unknownBecause('input_unreadable');
     }
 }
+export function localAllowLandingRedeemability(rule, landing) {
+    try {
+        if (typeof rule !== 'string' || rule.trim() === '')
+            return unknownBecause('input_unreadable');
+        if (typeof landing !== 'object' || landing === null)
+            return unknownBecause('input_unreadable');
+        return localAllowRedeemability({
+            subject: 'declared',
+            rule,
+            source: readOwnDataValue(landing, 'source'),
+            workspace: readOwnDataValue(landing, 'workspace'),
+            managedRulesOnly: readOwnDataValue(landing, 'managedRulesOnly'),
+            scopeRoot: readOwnDataValue(landing, 'scopeRoot'),
+            store: readOwnDataValue(landing, 'store'),
+        });
+    }
+    catch {
+        return unknownBecause('input_unreadable');
+    }
+}
 export const LOCAL_ALLOW_REDEMPTION_REFUSALS = Object.freeze([
     'managed_only',
     'no_scope_root',

package/dist/hitl/parkOwnership.js

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

package/dist/hitl/parkResolver.js

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

package/dist/hitl/screenDecisionCards.js

@@ -1,6 +1,7 @@
 import { SCREEN_CARD_ORIGINS } from './gateIdentity.js';
 import { convergeEndedEngineGeneration, } from '../engineGenerationConvergence.js';
 import { checkpointRowVerdictOf } from '../checkpointRowVerdict.js';
+import { CHECKPOINT_INVALID_OUTCOME, CHECKPOINT_UNSUPPORTED_VERSION } from '../engineErrorCodes.js';
 import { planReviewCardFactsFrom } from '../planReviewCardFacts.js';
 import { slotReadOf } from '../wireFailureShape.js';
 import { PARK_GATE_KEY } from './screenCardCarriers.js';
@@ -291,8 +292,8 @@ function deepFreeze(v) {
     }
     return v;
 }
-const GOLD_LACKING = { kind: 'lacking', code: 'checkpoint.unsupported_version', reason: 'version_newer', sentence: 'Newer engine.' };
-const GOLD_DAMAGED = { kind: 'damaged', code: 'checkpoint.invalid_outcome', reason: 'requirements_damaged', sentence: 'Row damaged.' };
+const GOLD_LACKING = { kind: 'lacking', code: CHECKPOINT_UNSUPPORTED_VERSION, reason: 'version_newer', sentence: 'Newer engine.' };
+const GOLD_DAMAGED = { kind: 'damaged', code: CHECKPOINT_INVALID_OUTCOME, reason: 'requirements_damaged', sentence: 'Row damaged.' };
 function goldenCases() {
     const ALL = ['park-approval', 'park-question', 'plan-review', 'host-reopen-question'];
     const ready = (name, cards, rows, pick, over = {}) => {

package/dist/hitl/sessionPolicyWire.js

@@ -3,7 +3,7 @@ import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { hostLog } from '../host.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { ruleToolNameVerdictOf } from '../protocolSegment.js';
-import { RULES_INERT_ENTRY, RULES_INVALID_SHAPE, isRulesRefusalCode } from '../engineErrorCodes.js';
+import { CORRUPT_ROW_ERROR_CODE, RULES_INERT_ENTRY, RULES_INVALID_SHAPE, isRulesRefusalCode } from '../engineErrorCodes.js';
 import { deniedEntryToolName } from '../engineToolDirectory.js';
 import { rosterMountedNames } from '../rosterMountedNames.js';
 import { CORE_ALLOW_ENTRY_INERT_REASONS, CORE_RULE_TOOL_NAME_VERDICTS } from '../generated/engineFactTables.js';
@@ -64,7 +64,7 @@ export function classifySessionPolicyFailure(e) {
     }
     if (errorCode === 'loosen_forbidden')
         return { kind: 'loosen-forbidden', message };
-    if (errorCode === 'corrupt')
+    if (errorCode === CORRUPT_ROW_ERROR_CODE)
         return { kind: 'store-corrupt', message };
     if (errorCode === 'conflict')
         return { kind: 'cas-conflict', message };

package/dist/hitl/standingRows.d.ts

@@ -1,6 +1,6 @@
 import { type PermissionsKeptReason } from '../permissionsDeclaration.js';
 import type { PermissionsAllowGrantReading } from '../permissionsAllowGrantCapability.js';
-import { type LocalAllowOfferedFacts } from './localAllowRedemption.js';
+import { type LocalAllowDeclaredFacts, type LocalAllowOfferedFacts, type LocalAllowRedeemability } from './localAllowRedemption.js';
 export type StandingRowWhy = 'given' | 'card_unreadable' | 'remember_refused' | 'remember_unreadable' | 'route_cannot_carry' | 'classes_unreadable' | 'not_deployment_list_question' | 'evidence_unreadable' | 'offers_unreadable' | 'engine_lane_closed' | 'args_unavailable' | 'grant_binding' | 'tool_name_unreadable' | 'rule_cannot_clear' | 'host_fact_missing' | 'card_face_absent' | 'face_not_generic' | 'rule_not_sent' | 'redemption_closed' | 'redemption_unknown';
 export type StandingPersistentRow = 'engine_offer' | 'local_whole_tool' | 'none';
 export interface StandingRowsWhy {
@@ -17,6 +17,7 @@ export interface StandingRows {
 export interface StandingRowsHostFacts {
     readonly wholeToolRuleSent?: boolean;
     readonly readOnlyRedemption?: LocalAllowOfferedFacts;
+    readonly wholeToolLanding?: LocalAllowDeclaredFacts;
 }
 export declare function standingRowsOf(card: object | null | undefined, host?: StandingRowsHostFacts | null): StandingRows;
 export declare function seatSessionRowOf(card: object | null | undefined, requestId: string | undefined): boolean;
@@ -31,6 +32,7 @@ export declare function rememberOfferable(card: object | null | undefined, host?
 export interface LocalAllowRuleEnforcement {
     readonly enforceable: boolean;
     readonly engine: 'sent' | 'kept' | 'unreadable';
+    readonly redemption: LocalAllowRedeemability;
     readonly keptReason?: PermissionsKeptReason;
 }
-export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading): LocalAllowRuleEnforcement;
+export declare function localAllowRuleEnforceable(rule: string, caps: PermissionsAllowGrantReading, landing?: LocalAllowDeclaredFacts): LocalAllowRuleEnforcement;

package/dist/hitl/standingRows.js

@@ -6,7 +6,7 @@ import { inSlotReadOf, inValueOf } from '../wireFailureShape.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
 import { permissionsDeclarationReport } from '../permissionsDeclaration.js';
 import { readCardUnreadableEvidence, sessionAllowCardReadable, sessionAllowEligible } from './sessionAllowRoute.js';
-import { localAllowRedeemability } from './localAllowRedemption.js';
+import { localAllowLandingRedeemability, localAllowRedeemability } from './localAllowRedemption.js';
 const UNREADABLE = Symbol('unreadable');
 function ownData(v, key) {
     try {
@@ -103,6 +103,11 @@ function persistentRowOf(card, host, evidenceUnreadable) {
         return { row: 'none', why: 'host_fact_missing' };
     if (!sent)
         return { row: 'none', why: 'rule_not_sent' };
+    const judged = localAllowLandingRedeemability(tool, ownData(host, 'wholeToolLanding'));
+    if (judged.kind === 'not_redeemable')
+        return { row: 'none', why: 'redemption_closed' };
+    if (judged.kind === 'unknown')
+        return { row: 'none', why: 'redemption_unknown' };
     return { row: 'local_whole_tool', why: 'given' };
 }
 function enginePremiseOf(card) {
@@ -214,7 +219,7 @@ export function rememberOfferable(card, host) {
         deploymentList: SESSION_OFFER[rows.why.deploymentList],
     });
 }
-export function localAllowRuleEnforceable(rule, caps) {
+export function localAllowRuleEnforceable(rule, caps, landing) {
     let engine = 'unreadable';
     let keptReason;
     if (typeof rule === 'string' && rule.trim() !== '') {
@@ -234,9 +239,11 @@ export function localAllowRuleEnforceable(rule, caps) {
             engine = 'unreadable';
         }
     }
+    const redemption = localAllowLandingRedeemability(rule, landing);
     return Object.freeze({
-        enforceable: engine === 'sent',
+        enforceable: engine === 'sent' && redemption.kind === 'redeemable',
         engine,
+        redemption,
         ...(keptReason !== undefined ? { keptReason } : {}),
     });
 }

package/dist/hooksReaderGenerations.js

@@ -1,6 +1,6 @@
 import { engineVersionTier } from './supportFloor.js';
 const HOOKS_READER_GENERATIONS = Object.freeze([
-    Object.freeze({ from: '7.139.0', below: '7.147.0', notRead: Object.freeze(['onFailure']) }),
+    Object.freeze({ from: '7.139.0', below: '7.147.0', notRead: Object.freeze(['onFailure', 'rewakeMessage', 'rewakeSummary', 'cloud', 'continueOnBlock']) }),
 ]);
 const HOOKS_READER_FAIL_CLOSED = Object.freeze([...new Set(HOOKS_READER_GENERATIONS.flatMap((g) => g.notRead))]);
 export function hooksReaderNotReadKeys(serverVersion) {