@sema-agent/client-core 0.111.0 → 0.112.1

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/hitlBridge.d.ts

@@ -41,6 +41,7 @@ export interface PlanReviewOutcome {
     editedPlan?: string;
     reason?: string;
     permissionModeAfter?: PlanReviewModeAfter;
+    checkpointId?: string;
 }
 export declare const PLAN_REVIEW_MODE_AFTER_WORDS: readonly ["default", "acceptEdits"];
 export type PlanReviewModeAfter = (typeof PLAN_REVIEW_MODE_AFTER_WORDS)[number];

package/dist/hitl/hitlBridge.js

@@ -13,6 +13,7 @@ import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisio
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
 import { checkpointDeadlineStateOf, checkpointRowBarOf, checkpointRowBarSentence, unboundWayOutContent } from '../checkpointRowVerdict.js';
+import { DATA_FACE_LANGUAGE, msg, renderMessage } from '../i18n/translate.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -419,32 +420,44 @@ export class HitlBridge {
         return this.decideRaw(pending.sessionId, decision, opts);
     }
     async reviewPlan(outcome, opts) {
+        const decisionRaw = outcome.decision;
+        const decision = decisionRaw === 'approve' || decisionRaw === 'edit' || decisionRaw === 'reject' ? decisionRaw : undefined;
+        if (decision === undefined) {
+            throw new HitlSafetyError('plan-review decision must be "approve", "edit" or "reject"', 'bad_plan_edit');
+        }
         const kind = this.active?.gate.kind;
         if (kind && kind !== 'plan_review' && kind !== 'needs_review') {
             throw new HitlSafetyError(`cannot plan-review a "${kind}" gate — a plan decision must never resolve a tool approval`, 'wrong_gate');
         }
-        if (outcome.decision === 'edit') {
+        if (decision === 'edit') {
             if (!outcome.editedPlan || outcome.editedPlan.length === 0) {
                 throw new HitlSafetyError('plan-review "edit" requires a non-empty editedPlan', 'bad_plan_edit');
             }
         }
         else if (outcome.editedPlan !== undefined) {
-            throw new HitlSafetyError(`plan-review "${outcome.decision}" must NOT carry editedPlan`, 'bad_plan_edit');
+            throw new HitlSafetyError(`plan-review "${decision}" must NOT carry editedPlan`, 'bad_plan_edit');
         }
         const modeAfter = outcome.permissionModeAfter;
         if (modeAfter !== undefined && !isPlanReviewModeAfter(modeAfter)) {
             throw new HitlSafetyError('plan-review permissionModeAfter must be "default" or "acceptEdits"', 'bad_plan_mode');
         }
-        const req = { decision: outcome.decision };
+        const gateRaw = outcome.checkpointId;
+        const gate = typeof gateRaw === 'string' && gateRaw !== '' ? gateRaw : undefined;
+        if (gate === undefined && (decision === 'approve' || decision === 'edit')) {
+            throw new HitlSafetyError(renderMessage(msg('approval.planReview.bridge.gateIdMissing'), DATA_FACE_LANGUAGE), 'wrong_gate');
+        }
+        const req = { decision };
         if (modeAfter !== undefined && isPlanReviewModeAfter(modeAfter))
             req.permissionModeAfter = modeAfter;
-        if (outcome.decision === 'edit' && outcome.editedPlan !== undefined)
+        if (decision === 'edit' && outcome.editedPlan !== undefined)
             req.editedPlan = outcome.editedPlan;
         if (outcome.reason !== undefined) {
             const r = denyReasonForWire(outcome.reason, `plan-review ${this.taskId}`);
             if (r !== undefined)
                 req.reason = r;
         }
+        if (gate !== undefined)
+            req.checkpointId = gate;
         return this.client.assistant.planReview(this.taskId, req, opts);
     }
     async resumeResourceLimit(opts) {

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/planReviewCard.d.ts

@@ -1,13 +1,14 @@
 import { type PlanReviewCardFacts, type PlanReviewFactsTaken } from '../planReviewCardFacts.js';
 import { type MessageRef } from '../i18n/translate.js';
+import type { PlanReviewOutcomeCause } from '../planReviewOutcomeCause.js';
 import type { MessageKey } from '../i18n/messages.en.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
 export declare function planReviewCardNoteRef(facts: PlanReviewCardFacts): MessageRef | undefined;
 export declare function planReviewUnreadableNoteRef(): MessageRef;
 export declare function planReviewCardNote(facts: PlanReviewCardFacts, lang?: UiLanguage): string | undefined;
 export declare function planReviewAskAgainKey(facts: PlanReviewCardFacts | undefined): MessageKey;
-export type PlanReviewDecisionReason = 'card_missing' | 'card_withholds' | 'gate_moved' | 'gate_untrusted';
-export declare function planReviewDecisionReasonRef(reason: PlanReviewDecisionReason, card?: PlanReviewCardFacts): MessageRef;
+export type PlanReviewDecisionReason = Exclude<PlanReviewOutcomeCause, 'stored_form_unsupported'>;
+export declare function planReviewDecisionReasonRef(reason: PlanReviewOutcomeCause, card?: PlanReviewCardFacts): MessageRef | undefined;
 export interface PlanReviewLedgerSource {
     readonly runRow: (taskId: string, signal: AbortSignal) => Promise<object>;
     readonly frames: (taskId: string, signal: AbortSignal) => AsyncIterable<object>;

package/dist/hitl/planReviewCard.js

@@ -48,6 +48,8 @@ export function planReviewAskAgainKey(facts) {
 }
 export function planReviewDecisionReasonRef(reason, card) {
     switch (reason) {
+        case 'stored_form_unsupported':
+            return undefined;
         case 'card_missing':
             return msg('approval.planReview.decision.cardMissing');
         case 'card_withholds': {

package/dist/hitl/planReviewWire.d.ts

@@ -3,6 +3,8 @@ import type { EngineWireInjection } from '../engineWireSdk.js';
 import { type PlanReviewModeAfter } from './hitlBridge.js';
 import type { AgentClient } from '@sema-agent/sdk';
 import { isPlanReviewPark, type PlanReviewCardFacts } from '../planReviewCardFacts.js';
+import { type PlanReviewOutcomeCause } from '../planReviewOutcomeCause.js';
+export type { PlanReviewOutcomeCause } from '../planReviewOutcomeCause.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
 import type { ReopenCardVerdict } from '../adapter/activeRunSelfHeal.js';
 export declare const PLAN_REVIEW_APPROVE_LABEL = "Yes, approve and run the plan";
@@ -80,10 +82,10 @@ export interface PlanReviewOutcomeMeta {
     dispatchNo: number;
     decision: 'approve' | 'reject' | 'ask_again';
     effect: PlanReviewDecisionEffect;
-    cause?: 'stored_form_unsupported';
+    cause?: PlanReviewOutcomeCause;
     questionId?: string;
 }
-export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect, cause?: 'stored_form_unsupported'): string;
+export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect, cause?: PlanReviewOutcomeCause): string;
 export type PlanReviewWireClient = {
     assistant: Pick<AgentClient['assistant'], 'planReview'>;
     runs: Pick<AgentClient['runs'], 'get'> & Partial<Pick<AgentClient['runs'], 'events'>>;