@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/generated/settingsSchemaHash.js

@@ -0,0 +1,58 @@
+export const SETTINGS_HASH_CLOSURE = (UNINSPECTABLE, containerView, inspect, valueOfDescriptor, jsonShapeOf) => {
+    const MAX_HASH_DEPTH = 200;
+    function stableStringify(v, depth = 0) {
+        if (depth > MAX_HASH_DEPTH)
+            throw new Error(`stableStringify: value nested deeper than ${MAX_HASH_DEPTH} — refusing to hash (a config value is pathologically deep or cyclic)`);
+        if (v === undefined)
+            return "null";
+        const shape = jsonShapeOf(v);
+        switch (shape) {
+            case "null":
+            case "primitive":
+                return JSON.stringify(v);
+            case "uninspectable":
+                throw new TypeError(`stableStringify: ${UNINSPECTABLE} — refusing to hash`);
+            case "array": {
+                const view = readOrRefuse(() => containerView(v, true, "wide"));
+                const length = readOrRefuse(() => lengthOf(view.length));
+                const byIndex = new Map(view.members);
+                let out = "";
+                for (let i = 0; i < length; i++) {
+                    const d = byIndex.get(String(i));
+                    out += `${i === 0 ? "" : ","}${d === undefined ? "" : stableStringify(readOrRefuse(() => valueOfDescriptor(v, d)), depth + 1)}`;
+                }
+                return `[${out}]`;
+            }
+            case "plain":
+            case "non_plain_object": {
+                if (typeof v === "function")
+                    return JSON.stringify(v);
+                const members = readOrRefuse(() => containerView(v, false, "wide")).members.slice().sort(([a], [b]) => (a < b ? -1 : 1));
+                let out = "";
+                for (const [key, d] of members) {
+                    const value = readOrRefuse(() => valueOfDescriptor(v, d));
+                    out += `${out === "" ? "" : ","}${JSON.stringify(key)}:${stableStringify(value, depth + 1)}`;
+                }
+                return `{${out}}`;
+            }
+            default: {
+                const unhandled = shape;
+                throw new Error(`stableStringify: unhandled shape ${String(unhandled)}`);
+            }
+        }
+    }
+    function readOrRefuse(read) {
+        const r = inspect(read);
+        if (!r.ok)
+            throw new TypeError(`stableStringify: ${r.sentence} — refusing to hash`);
+        return r.value;
+    }
+    function lengthOf(value) {
+        const n = +value;
+        const length = Number.isNaN(n) || n <= 0 ? 0 : Math.floor(n);
+        if (length > 2 ** 32 - 1)
+            throw new RangeError("Invalid array length");
+        return length;
+    }
+    return { stableStringify, MAX_HASH_DEPTH };
+};

package/dist/generated/settingsSchemaOwnKeyRead.js

@@ -137,6 +137,11 @@ export const SETTINGS_OWN_KEY_READ_CLOSURE = (isJsonArray) => {
         return Number.isInteger(n) && n >= 0 && n < 2 ** 32 - 1 && String(n) === key;
     };
     const NOT_PLAIN_DATA = "a value that is not plain data (a class instance, a Map, a Date, a function, an object with a hidden — non-enumerable — or an accessor own property … — only plain objects, arrays and primitives are)";
+    const COPY_PROTOTYPE = Object.freeze(Object.create(null, {
+        toString: { value: Object.freeze(function toString() { return "[object Object]"; }), enumerable: false },
+        valueOf: { value: Object.freeze(function valueOf() { return this; }), enumerable: false },
+    }));
+    const isolatedObject = () => Object.create(COPY_PROTOTYPE);
     function appendOwn(list, value) {
         Object.defineProperty(list, list.length, dataDescriptor(value));
     }
@@ -168,5 +173,5 @@ export const SETTINGS_OWN_KEY_READ_CLOSURE = (isJsonArray) => {
         });
         return read.ok ? read.value : undefined;
     }
-    return { captureStringArray, UNINSPECTABLE, dataDescriptor, inspect, ownFieldsOf, ownValueOf, readKey };
+    return { captureStringArray, UNINSPECTABLE, dataDescriptor, inspect, ownFieldsOf, ownValueOf, readKey, containerView, valueOfDescriptor, isAccessorDescriptor, isolatedObject };
 };

package/dist/generated/settingsSchemaTables.d.ts

@@ -1,4 +1,5 @@
-export declare const SETTINGS_ENGINE_OWNED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit"];
+export declare const SETTINGS_ENGINE_OWNED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit", "PermissionDenied"];
+export declare const SETTINGS_ENGINE_OWNED_HOOK_EVENT_SINCE: Readonly<Record<(typeof SETTINGS_ENGINE_OWNED_HOOK_EVENTS)[number], string>>;
 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;
@@ -9,7 +10,7 @@ export declare const SETTINGS_BUDGET_NUMBER_KEYS: readonly ["maxBudgetUsd", "tpm
 export declare const SETTINGS_BUDGET_STRING_KEYS: readonly ["mode", "budgetDuration", "enforcement"];
 export declare const SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS: readonly ["maxBudgetUsd", "tpmLimit", "rpmLimit"];
 export declare const SETTINGS_MODEL_API_WORDS: readonly ["openai-completions", "anthropic-messages"];
-export declare const SETTINGS_TOOL_NAME_MATCHER_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure"];
+export declare const SETTINGS_TOOL_NAME_MATCHER_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionDenied"];
 export declare const SETTINGS_UI_LANGUAGE_VALUES: readonly ["en", "zh"];
 export declare const SETTINGS_MCP_CONTENT_ORIGINS: readonly ["local", "execution", "external"];
 export declare const SETTINGS_MIN_TRUST_WORDS: readonly ["local", "session", "project", "global", "managed", "task"];

package/dist/generated/settingsSchemaTables.js

@@ -8,7 +8,20 @@ export const SETTINGS_ENGINE_OWNED_HOOK_EVENTS = Object.freeze([
     "Stop",
     "StopFailure",
     "UserPromptSubmit",
+    "PermissionDenied",
 ]);
+export const SETTINGS_ENGINE_OWNED_HOOK_EVENT_SINCE = Object.freeze({
+    "PreToolUse": "1.0.0",
+    "PostToolUse": "1.0.0",
+    "PostToolUseFailure": "1.0.0",
+    "PostToolBatch": "1.0.0",
+    "PreCompact": "1.0.0",
+    "PostCompact": "1.0.0",
+    "Stop": "1.0.0",
+    "StopFailure": "1.0.0",
+    "UserPromptSubmit": "1.0.0",
+    "PermissionDenied": "26.0.0",
+});
 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}$/);
@@ -41,6 +54,7 @@ export const SETTINGS_TOOL_NAME_MATCHER_EVENTS = Object.freeze([
     "PreToolUse",
     "PostToolUse",
     "PostToolUseFailure",
+    "PermissionDenied",
 ]);
 export const SETTINGS_UI_LANGUAGE_VALUES = Object.freeze([
     "en",

package/dist/generated/settingsSchemaTightenVerdict.d.ts

@@ -0,0 +1 @@
+export declare const SETTINGS_TIGHTEN_CLOSURE: (MAX_HASH_DEPTH: number, stableStringify: (v: unknown, depth?: number) => string, captureStringArray: (v: unknown, classification: "strict" | "wide") => string[] | undefined, dataDescriptor: (value: unknown) => PropertyDescriptor, isAccessorDescriptor: (d: PropertyDescriptor) => boolean, isolatedObject: () => object, jsonShapeOf: (v: unknown) => "plain" | "non_plain_object" | "array" | "null" | "primitive" | "uninspectable") => any;

package/dist/generated/settingsSchemaTightenVerdict.js

@@ -0,0 +1,125 @@
+export const SETTINGS_TIGHTEN_CLOSURE = (MAX_HASH_DEPTH, stableStringify, captureStringArray, dataDescriptor, isAccessorDescriptor, isolatedObject, jsonShapeOf) => {
+    function orderVerdict(diff) {
+        return diff > 0 ? "stricter" : diff < 0 ? "looser" : "equal";
+    }
+    function stringSetOf(v) {
+        const list = captureStringArray(v, "strict");
+        return list === undefined ? undefined : new Set(list);
+    }
+    function setVerdict(existing, candidate, supersetIsStricter) {
+        const a = stringSetOf(existing);
+        const b = stringSetOf(candidate);
+        if (a === undefined || b === undefined)
+            return "unreadable";
+        const candidateCoversExisting = [...a].every((x) => b.has(x));
+        const existingCoversCandidate = [...b].every((x) => a.has(x));
+        if (candidateCoversExisting && existingCoversCandidate)
+            return "equal";
+        if (candidateCoversExisting)
+            return supersetIsStricter ? "stricter" : "looser";
+        if (existingCoversCandidate)
+            return supersetIsStricter ? "looser" : "stricter";
+        return "unordered";
+    }
+    function isNumericLowerValue(v) {
+        return typeof v === "number" && (Number.isFinite(v) || v === Number.POSITIVE_INFINITY);
+    }
+    const NOT_STRICT_JSON = { ok: false };
+    function strictJsonCopy(v, depth = 0) {
+        if (depth > MAX_HASH_DEPTH)
+            return NOT_STRICT_JSON;
+        const shape = jsonShapeOf(v);
+        switch (shape) {
+            case "null":
+                return { ok: true, value: v };
+            case "primitive":
+                if (typeof v === "string" || typeof v === "boolean")
+                    return { ok: true, value: v };
+                return typeof v === "number" && Number.isFinite(v) ? { ok: true, value: v } : NOT_STRICT_JSON;
+            case "array": {
+                const array = v;
+                const length = array.length;
+                if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0)
+                    return NOT_STRICT_JSON;
+                const out = [];
+                for (let i = 0; i < length; i++) {
+                    const member = strictJsonStored(Object.getOwnPropertyDescriptor(array, i), depth);
+                    if (!member.ok)
+                        return NOT_STRICT_JSON;
+                    Object.defineProperty(out, i, dataDescriptor(member.value));
+                }
+                return { ok: true, value: out };
+            }
+            case "plain": {
+                const record = v;
+                const out = isolatedObject();
+                for (const key of Reflect.ownKeys(record)) {
+                    if (typeof key === "symbol")
+                        continue;
+                    const desc = Object.getOwnPropertyDescriptor(record, key);
+                    if (desc !== undefined && desc.enumerable !== true)
+                        continue;
+                    const member = strictJsonStored(desc, depth);
+                    if (!member.ok)
+                        return NOT_STRICT_JSON;
+                    Object.defineProperty(out, key, dataDescriptor(member.value));
+                }
+                return { ok: true, value: out };
+            }
+            case "non_plain_object":
+            case "uninspectable":
+                return NOT_STRICT_JSON;
+            default: {
+                const unhandled = shape;
+                throw new Error(`strictJsonCopy: unhandled shape ${String(unhandled)}`);
+            }
+        }
+    }
+    function strictJsonStored(desc, depth) {
+        if (desc === undefined || isAccessorDescriptor(desc))
+            return NOT_STRICT_JSON;
+        return strictJsonCopy(desc.value, depth + 1);
+    }
+    function noneVerdict(existing, candidate) {
+        try {
+            const a = strictJsonCopy(existing);
+            const b = strictJsonCopy(candidate);
+            if (!a.ok || !b.ok)
+                return "unreadable";
+            return stableStringify(a.value) === stableStringify(b.value) ? "equal" : "unordered";
+        }
+        catch {
+            return "unreadable";
+        }
+    }
+    function tightenVerdict(rule, existing, candidate) {
+        switch (rule.rule) {
+            case "enumRank": {
+                const a = typeof existing === "string" ? rule.order.indexOf(existing) : -1;
+                const b = typeof candidate === "string" ? rule.order.indexOf(candidate) : -1;
+                return a < 0 || b < 0 ? "unreadable" : orderVerdict(b - a);
+            }
+            case "boolStricter":
+                if (typeof existing !== "boolean" || typeof candidate !== "boolean")
+                    return "unreadable";
+                return existing === candidate ? "equal" : candidate === rule.strict ? "stricter" : "looser";
+            case "setUnion":
+                return setVerdict(existing, candidate, true);
+            case "setNarrower":
+                return setVerdict(existing, candidate, false);
+            case "numericLower":
+                if (!isNumericLowerValue(existing) || !isNumericLowerValue(candidate))
+                    return "unreadable";
+                return existing === candidate ? "equal" : candidate < existing ? "stricter" : "looser";
+            case "none":
+                return noneVerdict(existing, candidate);
+            case "policyDenyWins":
+                throw new RangeError("tightenVerdict: policyDenyWins is the fold law between a category's members (deny beats allow), not an order on one value — compare a member through memberTighten(category, member)");
+            default: {
+                const unknown = rule;
+                throw new RangeError(`tightenVerdict: unknown rule '${String(unknown.rule)}' — not a TightenRule word`);
+            }
+        }
+    }
+    return { tightenVerdict };
+};

package/dist/headlessPermissionModeWire.d.ts

@@ -9,12 +9,17 @@ export interface HeadlessPermissionFlags {
     readonly missing?: true;
     readonly dangerouslySkipPermissions?: boolean;
 }
+export interface HeadlessPermissionSettingsLayer {
+    readonly defaultMode?: string;
+    readonly autoEligible?: boolean;
+    readonly sessionMode?: string | null;
+}
 export type HeadlessPermissionResolution = {
     fields: PermissionModeField;
-    source: 'flag' | 'env' | 'default';
+    source: 'flag' | 'env' | 'settings' | 'default';
     warning?: string;
 };
-export declare function resolveHeadlessPermissionMode(flags: HeadlessPermissionFlags | undefined, env?: EnvLike, permissionModes?: PermissionModesReading): HeadlessPermissionResolution;
+export declare function resolveHeadlessPermissionMode(flags: HeadlessPermissionFlags | undefined, env?: EnvLike, permissionModes?: PermissionModesReading, settings?: HeadlessPermissionSettingsLayer): HeadlessPermissionResolution;
 export type HeadlessPermissionModeKnob = {
     readonly kind: 'absent';
 } | {

package/dist/headlessPermissionModeWire.js

@@ -3,10 +3,13 @@ import { permissionModeAdmitted } from './permissionModesCapability.js';
 import { hostEnv } from './hostEnv.js';
 import { flagString, flagTrue } from './flagInput.js';
 import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
-import { readOwnDataValue } from './ownKey.js';
+import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
+import { SETTINGS_JSON_SHAPE_OF, SETTINGS_SAFETY_MERGE_SPEC, SETTINGS_TIGHTEN_VERDICT } from './generated/settingsSchemaFns.js';
+import { quoteUntrustedForSentence } from './displayUntrusted.js';
 export const HEADLESS_PERMISSION_MODE_ENV = 'SEMA_HEADLESS_PERMISSION_MODE';
 export const HEADLESS_PERMISSION_WIRE_MODES = [...PERMISSION_MODE_WORDS];
 const SHELL_INTERNAL_MODE_TO_WIRE = new Map([['manual', 'default']]);
+const LAUNCH_FLAG_ONLY_MODE = 'bypassPermissions';
 export function normalizeShellPermissionModeForWire(mode) {
     if (mode === undefined)
         return undefined;
@@ -21,7 +24,7 @@ function permissionModeOfFlags(flags) {
     return undefined;
 }
 let warnedInvalidEnv = false;
-export function resolveHeadlessPermissionMode(flags, env = hostEnv(), permissionModes) {
+export function resolveHeadlessPermissionMode(flags, env = hostEnv(), permissionModes, settings) {
     const flagMode = permissionModeOfFlags(flags);
     if (flagMode !== undefined) {
         const snap = flagMode === 'dontAsk' ? dontAskSnapshot(permissionModes) : undefined;
@@ -31,6 +34,9 @@ export function resolveHeadlessPermissionMode(flags, env = hostEnv(), permission
     }
     const knob = readHeadlessPermissionModeKnob(env);
     if (knob.kind === 'absent') {
+        const fromSettings = settingsLayerField(settings, permissionModes);
+        if (fromSettings !== undefined)
+            return { fields: fromSettings, source: 'settings' };
         return { fields: permissionModeField('default', { stampDefault: true }), source: 'default' };
     }
     if (knob.kind === 'word') {
@@ -46,16 +52,72 @@ export function resolveHeadlessPermissionMode(flags, env = hostEnv(), permission
         }
         return resolution;
     }
-    const resolution = {
-        fields: permissionModeField('default', { stampDefault: true }),
-        source: 'default',
-    };
+    const fromSettings = settingsLayerField(settings, permissionModes);
+    const resolution = fromSettings !== undefined
+        ? { fields: fromSettings, source: 'settings' }
+        : { fields: permissionModeField('default', { stampDefault: true }), source: 'default' };
     if (!warnedInvalidEnv) {
         warnedInvalidEnv = true;
-        resolution.warning = knob.warning;
+        resolution.warning = fromSettings !== undefined ? invalidKnobSettingsWarning(knob.raw, fromSettings.permissionMode ?? 'default') : knob.warning;
     }
     return resolution;
 }
+function settingsLayerField(settings, permissionModes) {
+    const carrier = settingsCarrierOf(settings);
+    if (carrier === undefined)
+        return undefined;
+    const word = flagString(carrier, 'defaultMode');
+    if (word === undefined || word === LAUNCH_FLAG_ONLY_MODE || !HEADLESS_PERMISSION_WIRE_MODES.includes(word))
+        return undefined;
+    const rejectedAuto = word === 'auto' && !flagTrue(carrier, 'autoEligible');
+    const chosen = tightenToSession(rejectedAuto ? 'default' : word, readSessionMode(carrier));
+    if (chosen === undefined || (rejectedAuto && chosen === 'default'))
+        return undefined;
+    const snap = chosen === 'dontAsk' ? dontAskSnapshot(permissionModes) : undefined;
+    return permissionModeField(chosen, { stampDefault: true, permissionModes: snap });
+}
+function settingsCarrierOf(settings) {
+    const shape = SETTINGS_JSON_SHAPE_OF(settings);
+    switch (shape) {
+        case 'plain':
+            return settings;
+        case 'non_plain_object':
+        case 'array':
+        case 'null':
+        case 'primitive':
+        case 'uninspectable':
+            return undefined;
+        default: {
+            const unreachable = shape;
+            return unreachable;
+        }
+    }
+}
+function readSessionMode(carrier) {
+    try {
+        const v = ownDataField(carrier, 'sessionMode');
+        if (typeof v === 'string')
+            return Object.freeze({ kind: 'word', word: v });
+        if (v === null)
+            return Object.freeze({ kind: 'none' });
+        if (v !== undefined)
+            return Object.freeze({ kind: 'unreadable' });
+        return 'sessionMode' in carrier && !Object.hasOwn(carrier, 'sessionMode') ? Object.freeze({ kind: 'unreadable' }) : Object.freeze({ kind: 'none' });
+    }
+    catch {
+        return Object.freeze({ kind: 'unreadable' });
+    }
+}
+function tightenToSession(word, session) {
+    if (session.kind === 'none')
+        return word;
+    return (session.kind === 'word' ? clampOnce(word, session.word) : undefined) ?? clampOnce(word, 'default');
+}
+function clampOnce(word, session) {
+    const rule = guardedRead(() => readOwnDataValue(readOwnDataValue(SETTINGS_SAFETY_MERGE_SPEC, 'permissionMode'), 'tighten'));
+    const verdict = rule === undefined ? undefined : guardedRead(() => SETTINGS_TIGHTEN_VERDICT(rule, word, session));
+    return verdict === 'stricter' ? session : verdict === 'equal' || verdict === 'looser' ? word : undefined;
+}
 export function readHeadlessPermissionModeKnob(env = hostEnv()) {
     const raw = env[HEADLESS_PERMISSION_MODE_ENV]?.trim();
     if (raw === undefined || raw === '')
@@ -65,9 +127,16 @@ export function readHeadlessPermissionModeKnob(env = hostEnv()) {
     return Object.freeze({
         kind: 'invalid',
         raw,
-        warning: `sema: ${HEADLESS_PERMISSION_MODE_ENV}="${raw}" is not a recognized permission mode (expected one of: ${HEADLESS_PERMISSION_WIRE_MODES.join(', ')}) — ignoring it, this run keeps the default permission behavior`,
+        warning: `sema: ${HEADLESS_PERMISSION_MODE_ENV}=${shownKnobValue(raw)} is not a recognized permission mode (expected one of: ${HEADLESS_PERMISSION_WIRE_MODES.join(', ')}) — ignoring it, this run keeps the default permission behavior`,
     });
 }
+function invalidKnobSettingsWarning(raw, mode) {
+    return `sema: ${HEADLESS_PERMISSION_MODE_ENV}=${shownKnobValue(raw)} is not a recognized permission mode (expected one of: ${HEADLESS_PERMISSION_WIRE_MODES.join(', ')}) — ignoring it, this run uses "${mode}" from settings`;
+}
+const KNOB_VALUE_SHOWN_MAX = 64;
+function shownKnobValue(raw) {
+    return quoteUntrustedForSentence(raw, KNOB_VALUE_SHOWN_MAX) ?? '""';
+}
 export function headlessDontAskDowngradeWarning(permissionModes) {
     return `sema: ${HEADLESS_PERMISSION_MODE_ENV}="dontAsk" is only sent once this client knows the engine accepts that mode, and ${dontAskWithheldClause(permissionModes)} — this run uses "default"`;
 }

package/dist/hitl/approvalDecisionDoor.d.ts

@@ -0,0 +1,24 @@
+import type { AskDecisionBody, PersistRuleSelection } from '@sema-agent/sdk';
+export declare const ASK_DECISION_DOOR_SERVER_FROM = "7.152.0";
+export declare const APPROVAL_DECISION_DOORS: readonly ["ask_decision", "respond"];
+export type ApprovalDecisionDoor = (typeof APPROVAL_DECISION_DOORS)[number];
+export interface ApprovalAskDecisionVerb {
+    decideAsk(taskId: string, askId: string, body: AskDoorDecisionBody, opts?: {
+        signal?: AbortSignal;
+    }): Promise<{} | null | undefined>;
+}
+export interface ApprovalDecisionDoorReading {
+    readonly baseUrl?: string;
+    readonly serverVersion?: string;
+    readonly verbs?: ApprovalAskDecisionVerb;
+}
+export declare function approvalDecisionDoorSource(baseUrl?: string | undefined, verbs?: ApprovalAskDecisionVerb): ApprovalDecisionDoorReading;
+export declare function approvalDecisionDoorOf(reading: ApprovalDecisionDoorReading | undefined): ApprovalDecisionDoor;
+export declare function noteRespondDoorSwitch(reading: ApprovalDecisionDoorReading | undefined, logTag: string, approvalId: string): void;
+export declare function approvalDecisionVerbOf(reading: ApprovalDecisionDoorReading | undefined): ApprovalAskDecisionVerb['decideAsk'] | undefined;
+export declare const ROUTE_MISSING_WIRING_HINT = "approval answer got 404 not_found.route on the respond door and could not be retried on the ask decision door \u2014 pass approvalDecisionDoorSource(baseUrl, client.toolApprovals) as approvalDecisionDoor to sendHitlDecision deps and to the live-card lane options (and call invalidateEngineCaps(baseUrl) after an engine switch)";
+export declare function hitlAskIdempotencyKey(askId: string, verdict: 'approve' | 'deny'): string;
+export type AskDoorDecisionBody = AskDecisionBody & {
+    remember?: 'session';
+    persistRule?: PersistRuleSelection;
+};

package/dist/hitl/approvalDecisionDoor.js

@@ -0,0 +1,77 @@
+import { engineCapString, refreshEngineCapsOnce } from '../engineCapsCache.js';
+import { engineWireTargetBaseUrl } from '../engineWireTarget.js';
+import { hostLog } from '../host.js';
+import { engineVersionTier } from '../supportFloor.js';
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
+import { slotReadOf } from '../wireFailureShape.js';
+export const ASK_DECISION_DOOR_SERVER_FROM = '7.152.0';
+export const APPROVAL_DECISION_DOORS = Object.freeze(['ask_decision', 'respond']);
+void true;
+export function approvalDecisionDoorSource(baseUrl = engineWireTargetBaseUrl(), verbs) {
+    return Object.freeze({
+        ...(typeof baseUrl === 'string' && baseUrl !== '' ? { baseUrl } : {}),
+        ...(verbs !== undefined ? { verbs } : {}),
+    });
+}
+export function approvalDecisionDoorOf(reading) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return 'respond';
+        return engineVersionTier(decisionMomentVersionOf(reading), ASK_DECISION_DOOR_SERVER_FROM) === 'engine' ? 'ask_decision' : 'respond';
+    }
+    catch {
+        return 'respond';
+    }
+}
+function decisionMomentVersionOf(reading) {
+    const own = slotReadOf(reading, 'serverVersion');
+    if (own.presence === 'present')
+        return own.value;
+    if (own.presence === 'unreadable')
+        return undefined;
+    const baseUrl = readOwnDataNonEmptyString(reading, 'baseUrl');
+    return baseUrl !== undefined ? engineCapString(baseUrl, 'version') : undefined;
+}
+export function noteRespondDoorSwitch(reading, logTag, approvalId) {
+    try {
+        hostLog('debug', `${logTag}: respond answered not_found.route for ${approvalId} — the same decision goes once to the ask decision door`);
+        if (typeof reading !== 'object' || reading === null)
+            return;
+        const baseUrl = readOwnDataNonEmptyString(reading, 'baseUrl');
+        if (baseUrl !== undefined)
+            void refreshEngineCapsOnce(baseUrl, { withinMs: 0 });
+    }
+    catch {
+    }
+}
+export function approvalDecisionVerbOf(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    const holder = guardedRead(() => readOwnDataValue(reading, 'verbs'));
+    if (typeof holder !== 'object' || holder === null)
+        return undefined;
+    try {
+        const fn = holder['decideAsk'];
+        if (typeof fn !== 'function')
+            return undefined;
+        return (taskId, askId, body, opts) => {
+            try {
+                return Promise.resolve(fn.call(holder, taskId, askId, body, opts));
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export const ROUTE_MISSING_WIRING_HINT = 'approval answer got 404 not_found.route on the respond door and could not be retried on the ask decision door — pass approvalDecisionDoorSource(baseUrl, client.toolApprovals) as approvalDecisionDoor to sendHitlDecision deps and to the live-card lane options (and call invalidateEngineCaps(baseUrl) after an engine switch)';
+const IDEMPOTENCY_KEY_MAX = 255;
+export function hitlAskIdempotencyKey(askId, verdict) {
+    const head = `sema-ask:${askId}`;
+    const suffix = `:${verdict}`;
+    return head.length + suffix.length <= IDEMPOTENCY_KEY_MAX ? `${head}${suffix}` : `${head.slice(0, IDEMPOTENCY_KEY_MAX - suffix.length)}${suffix}`;
+}
+void true;

package/dist/hitl/approvalDelivery.d.ts

@@ -56,6 +56,8 @@ export interface ApprovalParkingFacts {
     readonly approvalId: string;
     readonly retryAfterMs?: number;
 }
+export declare function retryAfterMsOf(e: {} | null | undefined): number | undefined;
+export declare function askDoorParkingOfThrown(reading: TransportReading, approvalId: string): ApprovalParkingFacts | undefined;
 export declare function approvalParkingRetryWait(view: ApprovalParkingFacts, tally: SendTally, signal: AbortSignal | undefined): number | undefined;
 export type ApprovalDelivery = {
     readonly kind: 'answered';
@@ -81,7 +83,11 @@ export interface ApprovalDeliveryInput<B extends {
     readonly ladder: AttributionLadderState;
     readonly onLadderStep?: (step: AttributionLadderStep) => void;
     readonly parkingOf: (raw: {} | null | undefined) => ApprovalParkingFacts | undefined;
+    readonly parkingOfThrown?: (reading: TransportReading) => ApprovalParkingFacts | undefined;
 }
+export declare function respondRouteGoneOf(delivery: Extract<ApprovalDelivery, {
+    kind: 'thrown';
+}>): boolean;
 export declare function deliverApprovalDecision<B extends {
     settledBy?: unknown;
     decidedBy?: unknown;

package/dist/hitl/approvalDelivery.js

@@ -1,8 +1,9 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { classifyTurnWireError } from '../wireErrorTriage.js';
-import { ownReadingSlot, triageReadingOf } from '../engineWireFor.js';
-import { isSlotCarrier, readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
-import { deliverWithAttributionLadder, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
+import { effectiveCodeOf, ownReadingSlot, triageReadingOf } from '../engineWireFor.js';
+import { isSlotCarrier, readErrorNumber, readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
+import { ASK_PARKING_RETRY, ROUTE_NOT_FOUND } from '../engineErrorCodes.js';
+import { carrierReadOf, deliverWithAttributionLadder, isLocalSafetyStop, localCodeReadOf, topCauseReadOf } from './attributionLadder.js';
 import { GATE_FAILURE_CODES, refusalCarrierOf, safetyStopHeadOf } from './hitlBridge.js';
 const RETRY_DELAYS_MS = Object.freeze([500, 1_000, 2_000]);
 export const RETRY_BUDGET_MS = 8_000;
@@ -139,6 +140,29 @@ function settledReadingOf(e, reading, heads) {
 export function directFailureReadingOf(e, triaged, topHead) {
     return settledReadingOf(e, triaged, localStopHeadsOf(e, triaged, topHead));
 }
+export function retryAfterMsOf(e) {
+    if (!isSlotCarrier(e))
+        return undefined;
+    const ms = readErrorNumber(e, 'retryAfterMs');
+    if (ms !== undefined && Number.isFinite(ms) && ms >= 0)
+        return ms;
+    const sec = readErrorNumber(e, 'retryAfterSec');
+    return sec !== undefined && Number.isFinite(sec) && sec >= 0 ? sec * 1000 : undefined;
+}
+export function askDoorParkingOfThrown(reading, approvalId) {
+    try {
+        if (ownReadingSlot(reading, 'safetyStop') === true)
+            return undefined;
+        const answered = ownReadingSlot(reading, 'answered');
+        if (answered === undefined || effectiveCodeOf(answered.code) !== ASK_PARKING_RETRY)
+            return undefined;
+        const retryAfterMs = retryAfterMsOf(answered.layer);
+        return Object.freeze({ approvalId, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}) });
+    }
+    catch {
+        return undefined;
+    }
+}
 export function approvalParkingRetryWait(view, tally, signal) {
     const w = ownReadingSlot(view, 'retryAfterMs');
     if (typeof w !== 'number' || !Number.isFinite(w) || w < 0)
@@ -153,6 +177,15 @@ function thrownFacts(e, signal, tally) {
     const reading = settledTransportReadingOf(e, signal, tally);
     return { reading, transportExhausted: reading.cls === 'transport' && tally.retried, afterRetry: tally.retried };
 }
+export function respondRouteGoneOf(delivery) {
+    if (delivery.afterRetry)
+        return false;
+    const reading = delivery.reading;
+    const answered = ownReadingSlot(reading, 'answered');
+    if (answered === undefined || answered.status !== 404 || effectiveCodeOf(answered.code) !== ROUTE_NOT_FOUND)
+        return false;
+    return !isLocalSafetyStop(carrierReadOf(answered.layer, reading), reading);
+}
 export async function deliverApprovalDecision(input) {
     const { signal, tally } = input;
     let last = input.body;
@@ -164,7 +197,21 @@ export async function deliverApprovalDecision(input) {
         }, signal, input.ladder, input.onLadderStep, { kind: 'delivered', readingOf: (thrown) => deliveryReadingOf(thrown, tally) }));
     }
     catch (e) {
-        return { kind: 'thrown', error: e, ...thrownFacts(e, signal, tally) };
+        const facts = thrownFacts(e, signal, tally);
+        const failed = { kind: 'thrown', error: e, ...facts };
+        const readThrown = input.parkingOfThrown;
+        if (readThrown === undefined)
+            return failed;
+        let parkedThrown;
+        try {
+            parkedThrown = readThrown(facts.reading);
+        }
+        catch {
+            parkedThrown = undefined;
+        }
+        if (parkedThrown === undefined || parkedThrown.approvalId !== input.approvalId)
+            return failed;
+        return parkingResend(input, last, parkedThrown, failed);
     }
     let parking;
     try {
@@ -175,14 +222,17 @@ export async function deliverApprovalDecision(input) {
     }
     if (parking === undefined || parking.approvalId !== input.approvalId)
         return { kind: 'answered', raw };
+    return parkingResend(input, last, parking, { kind: 'answered', raw });
+}
+async function parkingResend(input, resent, parking, first) {
+    const { signal, tally } = input;
     const wait = approvalParkingRetryWait(parking, tally, signal);
     if (wait === undefined)
-        return { kind: 'answered', raw };
+        return first;
     await sleepFor(wait, signal);
     if (isAborted(signal) || budgetSpent(tally, 0))
-        return { kind: 'answered', raw };
+        return first;
     tally.retried = false;
-    const resent = last;
     try {
         const raw2 = (await withTransportRetry((sig) => input.send(resent, sig), signal, tally, true));
         return { kind: 'answered', raw: raw2, parkingRetried: true };