@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/cloudConfigWireCaps.js

@@ -1,6 +1,8 @@
 import { MCP_CAPS } from './mcpWireCaps.js';
 import { toCappedSpec } from './skillsWireCaps.js';
 import { TIER_ORDER } from './model/tierVocabulary.js';
+import { SETTINGS_NARROW_AT_MENTION } from './generated/settingsSchemaFns.js';
+import { modelsPolicyOf } from './model/modelsPolicy.js';
 import { SETTINGS_BUDGET_NUMBER_KEYS, SETTINGS_BUDGET_PER_MODEL_NUMBER_KEYS, SETTINGS_BUDGET_STRING_KEYS, SETTINGS_TIER_GROUP_NAME_RE, } from './generated/settingsSchemaTables.js';
 const asRec = (v) => (typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined);
 const asArr = (v) => (Array.isArray(v) ? v : []);
@@ -174,17 +176,26 @@ function modelsDocOf(models, opts) {
             written = stripped.filter((_, i) => acceptedFlags[i]);
     }
     const doc = { models: written };
-    if (accept && Object.hasOwn(m, 'default')) {
-        const d = m.default;
-        if (typeof d === 'string' && names.has(d))
-            doc.default = d;
+    const policy = modelsPolicyOf(m);
+    if (policy.unreadable) {
+        drop({ key: 'default', reason: 'unreadable' });
+        drop({ key: 'atModelAllowlist', at: 'models', reason: 'unreadable' });
+    }
+    if (policy.defaultUnreadable)
+        drop({ key: 'default', reason: 'unreadable' });
+    const dm = policy.defaultModel;
+    if (accept && dm !== undefined) {
+        if (names.has(dm.name))
+            doc.default = dm.name;
         else
-            drop({ key: 'default', ...refOf(d), reason: reasonOf(d) });
+            drop({ key: 'default', target: dm.name, reason: reasonOf(dm.name) });
     }
     const roles = asRec(m.roles);
     if (roles) {
         const kept = {};
         for (const [role, t] of Object.entries(roles)) {
+            if (role === 'default' && accept && dm?.from === 'roles.default')
+                continue;
             const tr = asRec(t);
             const model = tr && Object.hasOwn(tr, 'model') ? tr.model : undefined;
             if (typeof model === 'string' && !names.has(model)) {
@@ -195,19 +206,30 @@ function modelsDocOf(models, opts) {
         }
         doc.roles = kept;
     }
-    if (Array.isArray(m.atModelAllowlist)) {
-        const src = m.atModelAllowlist;
-        const keep = src.filter((n) => typeof n === 'string' && names.has(n));
-        if (keep.length === 0 && src.length > 0) {
-            doc.atModelAllowlist = src;
-            for (const n of src)
-                issues.push({ key: 'atModelAllowlist', ...refOf(n), reason: reasonOf(n), outcome: 'kept' });
+    const am = policy.atMention;
+    if (am?.kind === 'unreadable') {
+        drop({ key: 'atModelAllowlist', at: am.from, reason: 'unreadable' });
+    }
+    else if (am !== undefined) {
+        for (let i = 0; i < am.unreadableEntries; i += 1)
+            drop({ key: 'atModelAllowlist', reason: 'unreadable' });
+        const v = am.value;
+        if (v.mode === 'none') {
+            drop({ key: 'atModelAllowlist', at: 'atMention', reason: 'unsupported' });
         }
-        else {
-            for (const n of src)
-                if (!(typeof n === 'string' && names.has(n)))
-                    drop({ key: 'atModelAllowlist', ...refOf(n), reason: reasonOf(n) });
-            doc.atModelAllowlist = keep;
+        else if (v.mode === 'only') {
+            const narrowed = SETTINGS_NARROW_AT_MENTION(v, names);
+            if (narrowed.mode === 'only') {
+                for (const n of v.models)
+                    if (!names.has(n))
+                        drop({ key: 'atModelAllowlist', target: n, reason: reasonOf(n) });
+                doc.atModelAllowlist = [...narrowed.models];
+            }
+            else {
+                doc.atModelAllowlist = [...v.models];
+                for (const n of v.models)
+                    issues.push({ key: 'atModelAllowlist', target: n, reason: reasonOf(n), outcome: 'kept' });
+            }
         }
     }
     let groupNames;
@@ -494,8 +516,6 @@ const ENTRY_REJECTED = `is in the catalog, but its entry is one the local engine
 function warningNotice(w) {
     const where = quoted(w.domain, 'the configuration');
     switch (w.kind) {
-        case 'hosts-grandfathered':
-            return { level: 'warn', text: `cloud config warning: host entries exceeding the current limits were skipped by the registry${listOf(w.droppedNames, w.truncatedFrom)}` };
         case 'domain-defaulted':
             return { level: 'warn', text: `cloud config warning: ${where} could not be read by the registry and were served as defaults — what is configured there is not in effect` };
         case 'entry-dropped':
@@ -504,8 +524,6 @@ function warningNotice(w) {
             return { level: 'warn', text: `cloud config warning: the registry dropped unrecognised keys from ${where}${listOf(w.keys, w.truncatedFrom)}` };
         case 'unknown-keys-carried':
             return { level: 'warn', text: `cloud config warning: ${where} carry keys the registry does not recognise, passed on as written (check the spelling)${listOf(w.keys, w.truncatedFrom)}` };
-        case 'legacy-governance-lifted':
-            return { level: 'info', text: `cloud config note: ${where} were taken from their older location${listOf(w.keys, undefined)}` };
         case 'unread-config-file':
             return { level: 'warn', text: `cloud config warning: a configuration file was not read by the registry${w.file === undefined ? '' : ` (${w.file}${w.why === undefined ? '' : `: ${w.why}`})`}` };
         default:
@@ -523,6 +541,10 @@ function droppedRefNotice(d) {
         case 'roles':
             return { level: 'warn', text: `cloud config: role "${d.at ?? ''}" ${t === undefined ? 'names no readable model' : `points at model "${t}", which ${notServed}`} — the role was left out and falls back along the engine's role chain` };
         case 'atModelAllowlist':
+            if (d.reason === 'unsupported')
+                return { level: 'warn', text: 'cloud config: the @-mention setting served to you allows no model to be @-mentioned, which the local engine\'s settings format cannot express — it was left out, so @-mentions are not restricted on the local engine' };
+            if (d.at !== undefined)
+                return { level: 'warn', text: 'cloud config: the @-mention setting served to you could not be read by this client — it was left out, so @-mentions are not restricted on the local engine' };
             return { level: 'warn', text: `cloud config: ${t === undefined ? 'an unreadable @-mention allowlist entry' : `@-mention allowlist entry "${t}" ${notServed} and`} was left out` };
         case 'tierGroups':
             if (d.reason === 'duplicate')

package/dist/compensations.js

@@ -93,7 +93,7 @@ export const MIGRATED_COMPENSATIONS = [
             'adapt.ts importLedgerFromTranscript(消费口)',
         chromeArm: null,
         hostHalf: null,
-        retireOn: 'RL-37',
+        retireOn: null,
     },
     {
         id: 'T25',

package/dist/controlRouter.js

@@ -90,12 +90,9 @@ export class ControlRouter {
             return await this.client.runs.cancel(this.taskId, opts?.signal !== undefined ? { signal: opts.signal } : undefined);
         }
         catch (e) {
-            if (cancelConflictFromError(e)?.kind === 'run_not_running') {
-                throw controlSafetyRefusal('cancel_run_not_running', 'runs.cancel 409 conflict.run_not_running', cancelConflictContent({ kind: 'run_not_running' }), e);
-            }
-            if (isCancelSuspendedConflict(e)) {
-                throw controlSafetyRefusal('cancel_lost_race', 'runs.cancel 409', 'the pending gate was decided or expired concurrently (lost CAS race); ' +
-                    'check what that decision did to the run before retrying the cancel', e);
+            const conflict = cancelConflictFromError(e);
+            if (conflict !== null) {
+                throw controlSafetyRefusal(conflict.kind === 'run_not_running' ? 'cancel_run_not_running' : 'cancel_lost_race', conflict.code === undefined ? 'runs.cancel 409' : `runs.cancel 409 ${conflict.code}`, cancelConflictContent(conflict), e);
             }
             if (isNotFound(e)) {
                 throw controlSafetyRefusal('not_found', 'runs.cancel 404', `${CANCEL_NOT_FOUND_COPY.happened} — ${CANCEL_NOT_FOUND_COPY.nextStep}`, e);
@@ -310,10 +307,6 @@ export function steerBodyOf(input, reading) {
         throw steerLocalRefusal('priority_not_applied', tierMode);
     return Object.freeze({ ...base, priority });
 }
-function isCancelSuspendedConflict(e) {
-    const { name, status } = errCodes(e);
-    return name === 'ConflictError' || status === 409;
-}
 function isNotFound(e) {
     const { name, status } = errCodes(e);
     return name === 'NotFoundError' || status === 404;

package/dist/coreValuePorts.d.ts

@@ -48,6 +48,49 @@ export interface ValidatePermissionRulesOptionsView {
         readonly [base: string]: string | undefined;
     };
 }
+export interface AllowListReadingView {
+    readonly inert: readonly {
+        readonly entry: string;
+        readonly reason: string;
+    }[];
+}
+export interface RouteModelView {
+    readonly id: string;
+    readonly baseUrl: string;
+}
+export interface RouteCredentialInputView {
+    optionsApiKey?: string;
+    optionsHeaders?: Record<string, string>;
+    modelHeaders?: Record<string, string>;
+    configApiKey?: string;
+    configHeaders?: Record<string, string>;
+}
+export interface RouteCredentialView {
+    source: 'per-model' | 'deployment-config' | 'absent' | (string & {});
+    apiKey?: string;
+    headersBorne?: boolean;
+    carrierBag?: 'options' | 'model' | 'config' | (string & {});
+}
+export type RouteAdjudicationView = {
+    ok: true;
+    posture: 'per-model' | 'paired' | 'unpinned' | 'keyless' | (string & {});
+} | {
+    ok: false;
+    code: 'route.credential_mismatch' | 'route.credential_missing' | (string & {});
+    detail: RouteRefusalDetailView;
+};
+export interface RouteRefusalDetailView {
+    modelId: string;
+    entryBaseUrl: string;
+    requestBaseUrl: string;
+    configBaseUrl?: string;
+    fixHint: string;
+}
+export type RoutePairingStatusView = `ok:${string}` | `broken:${string}` | 'unknown';
+export interface PerModelAuthView {
+    apiKey?: string;
+    headers?: Record<string, string>;
+}
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
@@ -60,8 +103,18 @@ export interface CoreValuePorts {
     validatePermissionRules: (rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView) => PermissionRuleIssueView[];
     DISCUSSION_WORKFLOW_NAME: string;
     mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string;
+    compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView;
+    routeKeyOf(url: string | undefined): string;
+    joinRequestUrl(root: string | undefined, suffix: string): string;
+    resolveRouteCredential(input: RouteCredentialInputView): RouteCredentialView;
+    adjudicateModelRoute(model: RouteModelView, credential: RouteCredentialView, config: {
+        baseUrl?: string;
+    }): RouteAdjudicationView;
+    routePairingStatus(brain: {
+        adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
+    }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "RETIRED_TOOL_NAMES", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "DISCUSSION_WORKFLOW_NAME", "mintNamespacePrefix"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "RETIRED_TOOL_NAMES", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "DISCUSSION_WORKFLOW_NAME", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -78,3 +131,13 @@ export declare function ruleToolGrammarOf(toolName: string): 'command' | 'path'
 export declare function validatePermissionRules(rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView): PermissionRuleIssueView[] | undefined;
 export declare function discussionWorkflowName(): string | undefined;
 export declare function mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string | undefined;
+export declare function compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView | undefined;
+export declare function routeKeyOf(url: string | undefined): string | undefined;
+export declare function joinRequestUrl(root: string | undefined, suffix: string): string | undefined;
+export declare function resolveRouteCredential(input: RouteCredentialInputView): RouteCredentialView | undefined;
+export declare function adjudicateModelRoute(model: RouteModelView, credential: RouteCredentialView, config: {
+    baseUrl?: string;
+}): RouteAdjudicationView | undefined;
+export declare function routePairingStatus(brain: {
+    adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
+}, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;

package/dist/coreValuePorts.js

@@ -10,6 +10,12 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'validatePermissionRules',
     'DISCUSSION_WORKFLOW_NAME',
     'mintNamespacePrefix',
+    'compileAllowList',
+    'routeKeyOf',
+    'joinRequestUrl',
+    'resolveRouteCredential',
+    'adjudicateModelRoute',
+    'routePairingStatus',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -72,3 +78,27 @@ export function mintNamespacePrefix(ns, peer) {
     const fn = port('mintNamespacePrefix');
     return fn === undefined ? undefined : fn(ns, peer);
 }
+export function compileAllowList(entries, behavior, roster) {
+    const fn = port('compileAllowList');
+    return fn === undefined ? undefined : fn(entries, behavior, roster);
+}
+export function routeKeyOf(url) {
+    const fn = port('routeKeyOf');
+    return fn === undefined ? undefined : fn(url);
+}
+export function joinRequestUrl(root, suffix) {
+    const fn = port('joinRequestUrl');
+    return fn === undefined ? undefined : fn(root, suffix);
+}
+export function resolveRouteCredential(input) {
+    const fn = port('resolveRouteCredential');
+    return fn === undefined ? undefined : fn(input);
+}
+export function adjudicateModelRoute(model, credential, config) {
+    const fn = port('adjudicateModelRoute');
+    return fn === undefined ? undefined : fn(model, credential, config);
+}
+export function routePairingStatus(brain, model, perModelAuth) {
+    const fn = port('routePairingStatus');
+    return fn === undefined ? undefined : fn(brain, model, perModelAuth);
+}

package/dist/cycleOrder.d.ts

@@ -0,0 +1,15 @@
+export interface EngineAgentPanelCycleIdentity {
+    readonly cycleSeq?: number;
+    readonly startedAt?: number;
+}
+export type CycleOrder = 'before' | 'after' | 'same' | 'unknown';
+export declare function cycleSeqValue(v: unknown): number | undefined;
+export declare function cycleSeqOf(v: EngineAgentPanelCycleIdentity | null | undefined): number | undefined;
+export declare function startedAtOf(v: EngineAgentPanelCycleIdentity | null | undefined): number | undefined;
+export declare function cycleOrder(a: EngineAgentPanelCycleIdentity | null | undefined, b: EngineAgentPanelCycleIdentity | null | undefined): CycleOrder;
+export declare function cycleSeqOrder(a: number | undefined, b: number | undefined): CycleOrder;
+export declare function cycleOf(v: EngineAgentPanelCycleIdentity | null | undefined): EngineAgentPanelCycleIdentity;
+export declare function cycleEmpty(v: EngineAgentPanelCycleIdentity | null | undefined): boolean;
+export declare function cycleKeysChanged(prev: EngineAgentPanelCycleIdentity | null | undefined, next: EngineAgentPanelCycleIdentity | null | undefined): boolean;
+export declare function carryCycle(frame: EngineAgentPanelCycleIdentity, prev: EngineAgentPanelCycleIdentity | undefined, carry: boolean): EngineAgentPanelCycleIdentity;
+export declare function mergeCycle(prefer: EngineAgentPanelCycleIdentity, fallback: EngineAgentPanelCycleIdentity | undefined): EngineAgentPanelCycleIdentity;

package/dist/cycleOrder.js

@@ -0,0 +1,45 @@
+export function cycleSeqValue(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 1 ? v : undefined;
+}
+export function cycleSeqOf(v) {
+    return cycleSeqValue(v?.cycleSeq);
+}
+export function startedAtOf(v) {
+    const n = v?.startedAt;
+    return typeof n === 'number' && Number.isFinite(n) && n > 0 ? n : undefined;
+}
+export function cycleOrder(a, b) {
+    const ac = cycleSeqOf(a);
+    const bc = cycleSeqOf(b);
+    if (ac !== undefined && bc !== undefined)
+        return ac < bc ? 'before' : ac > bc ? 'after' : 'same';
+    const as = startedAtOf(a);
+    const bs = startedAtOf(b);
+    if (as !== undefined && bs !== undefined)
+        return as < bs ? 'before' : as > bs ? 'after' : 'same';
+    return 'unknown';
+}
+export function cycleSeqOrder(a, b) {
+    return cycleOrder(a === undefined ? undefined : { cycleSeq: a }, b === undefined ? undefined : { cycleSeq: b });
+}
+export function cycleOf(v) {
+    const c = cycleSeqOf(v);
+    const s = startedAtOf(v);
+    return { ...(c !== undefined ? { cycleSeq: c } : {}), ...(s !== undefined ? { startedAt: s } : {}) };
+}
+export function cycleEmpty(v) {
+    return cycleSeqOf(v) === undefined && startedAtOf(v) === undefined;
+}
+export function cycleKeysChanged(prev, next) {
+    const nc = cycleSeqOf(next);
+    const ns = startedAtOf(next);
+    return (nc !== undefined && nc !== cycleSeqOf(prev)) || (ns !== undefined && ns !== startedAtOf(prev));
+}
+export function carryCycle(frame, prev, carry) {
+    const c = cycleSeqOf(frame) ?? (carry ? cycleSeqOf(prev) : undefined);
+    const s = startedAtOf(frame) ?? (carry ? startedAtOf(prev) : undefined);
+    return { ...(c !== undefined ? { cycleSeq: c } : {}), ...(s !== undefined ? { startedAt: s } : {}) };
+}
+export function mergeCycle(prefer, fallback) {
+    return carryCycle(prefer, fallback, true);
+}

package/dist/decideFailureNote.js

@@ -2,6 +2,7 @@ import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriag
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
 import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
+import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
@@ -10,11 +11,13 @@ export function decideFailureNote(err, decision) {
     const bucket = settingsPermissionBucketRefusalFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
+    const answerInvalid = decisionConflictOf(err) === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
         (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
         (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`) +
-        (gone === null ? '' : ` — ${askGoneContent(gone)}`));
+        (gone === null ? '' : ` — ${askGoneContent(gone)}`) +
+        (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : ''));
 }

package/dist/decideReceipt.d.ts

@@ -1,6 +1,7 @@
 import { type GateOutcomeView } from './gateOutcome.js';
 import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
 import { type CrashConvergedRow } from './hitl/crashConverged.js';
+import type { AskRowEndingCause } from '@sema-agent/sdk';
 export interface DecideReceiptView {
     status?: string;
     taskId?: string;
@@ -33,7 +34,7 @@ export declare function decideParkMovedContent(detail: Pick<DecideParkMovedDetai
 export interface AskGoneDetail {
     code: 'gone.ask';
     state?: 'VOID' | 'DENIED';
-    deniedReason?: string;
+    endingCause?: AskRowEndingCause;
     holderGone?: CrashConvergedRow['cause'];
 }
 export declare function askGoneFromError(e: unknown): AskGoneDetail | null;

package/dist/decideReceipt.js

@@ -1,9 +1,10 @@
 import { gateOutcomeOf } from './gateOutcome.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
-import { ASK_GONE, ASK_GONE_DENIED_WORD, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { ASK_GONE, DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { readErrorString, readErrorStrictStringList } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
+import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -132,6 +133,38 @@ export function decideParkMovedContent(detail) {
     const extra = code === DECIDE_CLAIM_LOST ? '; if this approval is still listed, wait a little before deciding it again' : '';
     return `${what} · This decision was not applied — fetch the pending approvals again and decide from what is pending now${extra}`;
 }
+function askGoneRawCause(e) {
+    let top;
+    try {
+        top = e.endingCause;
+    }
+    catch {
+        top = undefined;
+    }
+    if (typeof top === 'string')
+        return top;
+    let extra;
+    try {
+        extra = e.extra;
+    }
+    catch {
+        extra = undefined;
+    }
+    if (typeof extra === 'object' && extra !== null && !Array.isArray(extra)) {
+        let hasCause = false;
+        let word;
+        try {
+            hasCause = Object.hasOwn(extra, 'cause');
+            word = hasCause ? extra.cause : undefined;
+        }
+        catch {
+            return undefined;
+        }
+        if (hasCause)
+            return word;
+    }
+    return readErrorString(e, 'deniedReason');
+}
 export function askGoneFromError(e) {
     if (typeof e !== 'object' || e === null)
         return null;
@@ -139,37 +172,32 @@ export function askGoneFromError(e) {
         return null;
     const rawState = readErrorString(e, 'state');
     const state = rawState === 'VOID' || rawState === 'DENIED' ? rawState : undefined;
-    const rawReason = readErrorString(e, 'deniedReason');
-    const deniedReason = rawReason === undefined || rawReason.length === 0
-        ? undefined
-        : state === 'DENIED'
-            ? rawReason === ASK_GONE_DENIED_WORD ? rawReason : undefined
-            : state === 'VOID' ? rawReason : undefined;
-    const holderGone = state === 'VOID' && isCrashConvergedCause(deniedReason) ? deniedReason : undefined;
+    const endingCause = askRowEndingCauseFor(state, askGoneRawCause(e));
+    const holderGone = state === 'VOID' && isCrashConvergedCause(endingCause) ? endingCause : undefined;
     return {
         code: ASK_GONE,
         ...(state !== undefined ? { state } : {}),
-        ...(deniedReason !== undefined ? { deniedReason } : {}),
+        ...(endingCause !== undefined ? { endingCause } : {}),
         ...(holderGone !== undefined ? { holderGone } : {}),
     };
 }
 export function askGoneContent(detail) {
     let state;
-    let deniedReason;
+    let endingCause;
     let holderGone;
     try {
         state = detail.state;
-        deniedReason = detail.deniedReason;
+        endingCause = detail.endingCause;
         holderGone = detail.holderGone;
     }
     catch {
         state = undefined;
-        deniedReason = undefined;
+        endingCause = undefined;
         holderGone = undefined;
     }
     const st = state === 'VOID' || state === 'DENIED' ? state : undefined;
     const safety = 'Your answer was not applied and nothing was run on it';
-    if (st === 'VOID' && (isCrashConvergedCause(holderGone) || isCrashConvergedCause(deniedReason))) {
+    if (st === 'VOID' && (isCrashConvergedCause(holderGone) || isCrashConvergedCause(endingCause))) {
         return [
             'The engine run that was waiting for this answer ended before the answer arrived',
             safety,

package/dist/declared/supportFloorDeclared.d.ts

@@ -0,0 +1 @@
+export declare const DECLARED_SUPPORT_FLOOR: Readonly<Record<"server" | "core" | "sdk", string>>;

package/dist/declared/supportFloorDeclared.js

@@ -0,0 +1,5 @@
+export const DECLARED_SUPPORT_FLOOR = Object.freeze({
+    server: "7.115.0",
+    core: "7.40.1",
+    sdk: "19.0.0",
+});

package/dist/detachWire.d.ts

@@ -10,10 +10,7 @@ export type DetachResolution = {
     on: false;
     reason: 'env-off';
 };
-export declare function resolveHeadlessDetach(_baseUrl: string, env?: EnvLike, _opts?: {
-    fetchImpl?: typeof fetch;
-    timeoutMs?: number;
-}): Promise<DetachResolution>;
+export declare function resolveHeadlessDetach(env?: EnvLike): Promise<DetachResolution>;
 export declare const DETACH_DURABLE_OFF_400_ANCHOR = "x-detach-on-disconnect requires a durable run";
 export declare function isDetachDurableOff400(err: unknown): boolean;
 export declare function detachDurableOffHint(err: unknown): string | null;

package/dist/detachWire.js

@@ -6,7 +6,7 @@ export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
 export function headlessDetachDisabledByEnv(env = hostEnv()) {
     return envFlagOff(env[HEADLESS_DETACH_ENV]);
 }
-export async function resolveHeadlessDetach(_baseUrl, env = hostEnv(), _opts) {
+export async function resolveHeadlessDetach(env = hostEnv()) {
     if (headlessDetachDisabledByEnv(env))
         return { on: false, reason: 'env-off' };
     return { on: true, reason: 'default-on' };

package/dist/deviceExecutorManagementCapability.d.ts

@@ -20,5 +20,4 @@ export declare function observedDeviceExecutorManagement(baseUrl?: string | unde
 export declare function deviceManagementVerbsAvailable(reading: DeviceExecutorManagementReading): 'yes' | 'no' | 'unknown';
 export declare function deviceLaneOpen(reading: DeviceExecutorManagementReading): 'yes' | 'no' | 'unknown';
 export declare function deviceExecutorManagementDoctorDetail(reading: DeviceExecutorManagementReading): string;
-export declare function forgetDeviceExecutorManagementReading(baseUrl: string | undefined): void;
 export declare function __resetDeviceExecutorManagementReadingsForTests(): void;

package/dist/deviceExecutorManagementCapability.js

@@ -1,45 +1,44 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { capForDisplay } from './fleetTaskDesc.js';
-function ownRead(o, key) {
-    return Object.hasOwn(o, key) ? o[key] : undefined;
-}
 export function projectDeviceExecutorManagementCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    const c = caps;
-    if (!Object.hasOwn(c, 'deviceExecutor'))
-        return { kind: 'not_reported', why: 'capability_absent' };
-    const d = c.deviceExecutor;
-    if (d === undefined)
-        return { kind: 'not_reported', why: 'capability_absent' };
-    if (d === false)
-        return { kind: 'lane_absent' };
-    if (d === null || typeof d !== 'object' || Array.isArray(d))
-        return undefined;
-    const o = d;
-    if (ownRead(o, 'enabled') !== true)
-        return undefined;
-    const mgmt = ownRead(o, 'management');
-    let management;
-    if (mgmt === undefined)
-        management = 'absent';
-    else if (mgmt === true)
-        management = 'present-true';
-    else if (mgmt === false)
-        management = 'present-false';
-    else
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const d = ownDataField(caps, 'deviceExecutor');
+        if (d === undefined)
+            return { kind: 'not_reported', why: 'capability_absent' };
+        if (d === false)
+            return { kind: 'lane_absent' };
+        if (d === null || typeof d !== 'object' || Array.isArray(d))
+            return undefined;
+        if (ownDataField(d, 'enabled') !== true)
+            return undefined;
+        const mgmt = ownDataField(d, 'management');
+        let management;
+        if (mgmt === undefined)
+            management = 'absent';
+        else if (mgmt === true)
+            management = 'present-true';
+        else if (mgmt === false)
+            management = 'present-false';
+        else
+            return undefined;
+        const pv = ownDataField(d, 'protocolVersion');
+        const mi = ownDataField(d, 'maxInflightPerDevice');
+        const ws = ownDataField(d, 'wsPath');
+        return {
+            kind: 'present',
+            management,
+            ...(typeof pv === 'number' && Number.isFinite(pv) ? { protocolVersion: pv } : {}),
+            ...(typeof mi === 'number' && Number.isFinite(mi) && mi >= 0 ? { maxInflightPerDevice: mi } : {}),
+            ...(typeof ws === 'string' && ws.length > 0 ? { wsPath: ws } : {}),
+        };
+    }
+    catch {
         return undefined;
-    const pv = ownRead(o, 'protocolVersion');
-    const mi = ownRead(o, 'maxInflightPerDevice');
-    const ws = ownRead(o, 'wsPath');
-    return {
-        kind: 'present',
-        management,
-        ...(typeof pv === 'number' && Number.isFinite(pv) ? { protocolVersion: pv } : {}),
-        ...(typeof mi === 'number' && Number.isFinite(mi) && mi >= 0 ? { maxInflightPerDevice: mi } : {}),
-        ...(typeof ws === 'string' && ws.length > 0 ? { wsPath: ws } : {}),
-    };
+    }
 }
 const reader = createEngineCapReader({
     name: 'deviceExecutor.management',
@@ -103,9 +102,6 @@ export function deviceExecutorManagementDoctorDetail(reading) {
         }
     }
 }
-export function forgetDeviceExecutorManagementReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetDeviceExecutorManagementReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/deviceFlowPolling.d.ts

@@ -0,0 +1,5 @@
+export interface DeviceFlowPollingPlan {
+    readonly timeoutMs: number;
+    readonly intervalSeconds: number;
+}
+export declare function deviceFlowPollingPlan(reading: unknown): DeviceFlowPollingPlan | undefined;