@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/atMostOnce.js

@@ -0,0 +1,36 @@
+import { errCodes, steeringRefusedBeforeEngine, steeringStatusIs4xx } from './controlRouter.js';
+function errorSlot(e, key) {
+    if (e === null || e === undefined)
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function atMostOnceFailureClass(e) {
+    const s = atMostOnceSnapshotOf(e);
+    if (steeringStatusIs4xx(s))
+        return 'rejected';
+    return steeringRefusedBeforeEngine(s) !== undefined ? 'rejected' : 'unknown';
+}
+function atMostOnceSnapshotOf(e) {
+    return {
+        status: errorSlot(e, 'status'),
+        statusCode: errorSlot(e, 'statusCode'),
+        errorCode: errorSlot(e, 'errorCode'),
+        name: errorSlot(e, 'name'),
+    };
+}
+export function atMostOnceVerdictOf(e) {
+    const snapshot = atMostOnceSnapshotOf(e);
+    const delivery = atMostOnceFailureClass(snapshot);
+    const { status, code, name } = errCodes(snapshot);
+    return {
+        delivery,
+        ...(status !== undefined ? { status } : {}),
+        ...(code !== undefined && code !== '' ? { code } : {}),
+        ...(name !== undefined && name !== '' ? { name } : {}),
+    };
+}

package/dist/attachmentSeatCapability.d.ts

@@ -7,5 +7,4 @@ export declare function noteEngineCapsForAttachmentSeat(baseUrl: string, caps: u
     generation?: number;
 }): void;
 export declare function observedAttachmentSeat(baseUrl?: string | undefined): AttachmentSeatReading;
-export declare function forgetAttachmentSeatReading(baseUrl: string | undefined): void;
 export declare function __resetAttachmentSeatReadingsForTests(): void;

package/dist/attachmentSeatCapability.js

@@ -19,9 +19,6 @@ export function noteEngineCapsForAttachmentSeat(baseUrl, caps, opts) {
 export function observedAttachmentSeat(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
-export function forgetAttachmentSeatReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetAttachmentSeatReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/attachmentsWireCaps.js

@@ -23,8 +23,14 @@ const OPT_IN_KEYS = [
     'mcpInstructions',
 ];
 const DEFAULT_ON_ONLY_KEYS = ['agentListing', 'skillsListing'];
-const DEFAULT_PAIR = ['backgroundTasks', 'toolsDelta'];
-const _attachmentsKeyPins = [true, true, true, true, true, true];
+const PRODUCT_DEFAULT_KEYS = ['backgroundTasks', 'toolsDelta', 'todoReminder'];
+function productDefaultAttachments() {
+    const out = {};
+    for (const k of PRODUCT_DEFAULT_KEYS)
+        out[k] = true;
+    return out;
+}
+const _attachmentsKeyPins = [true, true, true, true, true, true, true];
 void _attachmentsKeyPins;
 const TODO_REMINDER_MODES = ['baseline', 'off'];
 export class AttachmentsSpecRefused extends TypeError {
@@ -61,11 +67,11 @@ function judgeAttachmentsEnv(raw) {
             return { ok: false, refusal: { kind: 'retired_key', token, why: named.why, entry: i + 1, key: named.key, retired: named } };
     }
     if (tokens.length === 0)
-        return { ok: true, spec: { backgroundTasks: true, toolsDelta: true } };
+        return { ok: true, spec: productDefaultAttachments() };
     if (tokens.length === 1 && (tokens[0] === 'full' || tokens[0] === 'all'))
         return { ok: true, spec: allLiteralTrue() };
     if (tokens.length === 1 && !isKnownToken(tokens[0])) {
-        return { ok: true, spec: { backgroundTasks: true, toolsDelta: true } };
+        return { ok: true, spec: productDefaultAttachments() };
     }
     const spec = {};
     for (const [i, token] of tokens.entries()) {
@@ -74,8 +80,7 @@ function judgeAttachmentsEnv(raw) {
             continue;
         }
         if (token === 'default') {
-            for (const k of DEFAULT_PAIR)
-                spec[k] = true;
+            Object.assign(spec, productDefaultAttachments());
             continue;
         }
         if (token.startsWith('-')) {

package/dist/bashExitReading.d.ts

@@ -0,0 +1,10 @@
+export interface BashFrameExit {
+    readonly exitCode: number | null;
+    readonly note?: string;
+}
+export interface BashExitReading {
+    readonly exitCode: number | null;
+    readonly benignNote: string | undefined;
+}
+export declare function bashExitOf(structured: unknown, parseFrame: () => BashFrameExit | null): BashExitReading;
+export declare function bashExitReadingFailed(r: BashExitReading): boolean;

package/dist/bashExitReading.js

@@ -0,0 +1,12 @@
+export function bashExitOf(structured, parseFrame) {
+    const s = typeof structured === 'object' && structured !== null ? structured : undefined;
+    const interp = typeof s?.returnCodeInterpretation === 'string' && s.returnCodeInterpretation.length > 0 ? s.returnCodeInterpretation : undefined;
+    if (s?.type === 'bash' && typeof s.exitCode === 'number')
+        return { exitCode: s.exitCode, benignNote: interp };
+    const parsed = parseFrame();
+    const note = typeof parsed?.note === 'string' && parsed.note.length > 0 ? parsed.note : undefined;
+    return { exitCode: parsed?.exitCode ?? null, benignNote: interp ?? note };
+}
+export function bashExitReadingFailed(r) {
+    return r.exitCode !== null && r.exitCode !== 0 && r.benignNote === undefined;
+}

package/dist/callerCwdCapability.d.ts

@@ -12,5 +12,4 @@ export declare function noteEngineCapsForCallerCwd(baseUrl: string, caps: unknow
 }): void;
 export declare function observedCallerCwd(baseUrl?: string | undefined): CallerCwdReading;
 export declare function callerCwdAdmitted(reading: CallerCwdReading | undefined): boolean;
-export declare function forgetCallerCwdReading(baseUrl: string | undefined): void;
 export declare function __resetCallerCwdReadingsForTests(): void;

package/dist/callerCwdCapability.js

@@ -1,13 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectCallerCwdCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'callerCwd'))
-            return { kind: 'not_reported' };
-        const v = caps.callerCwd;
+        const v = ownDataField(caps, 'callerCwd');
         if (v === undefined)
             return { kind: 'not_reported' };
         return typeof v === 'boolean' ? { kind: 'present', value: v } : undefined;
@@ -39,9 +37,6 @@ export function callerCwdAdmitted(reading) {
         return false;
     }
 }
-export function forgetCallerCwdReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetCallerCwdReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/centerWiringCapability.d.ts

@@ -15,11 +15,10 @@ export interface CenterWiringView {
     usageReport: boolean;
     issuer: string;
     caller?: CenterWiringCallerView;
+    worker?: string;
 }
 export type CenterWiringReading = {
     kind: 'unobserved';
-} | {
-    kind: 'not_reported';
 } | {
     kind: 'none';
 } | {
@@ -34,5 +33,4 @@ export declare function observedCenterWiring(baseUrl?: string | undefined): Cent
 export type CallerQuotaLease = 'enforced' | 'not-enforced' | 'exhausted' | 'unobserved' | 'no-lease' | 'unknown';
 export declare function callerQuotaLease(reading: CenterWiringReading): CallerQuotaLease;
 export declare function centerWiringDoctorDetail(reading: CenterWiringReading): string;
-export declare function forgetCenterWiringReading(baseUrl: string | undefined): void;
 export declare function __resetCenterWiringReadingsForTests(): void;

package/dist/centerWiringCapability.js

@@ -1,12 +1,11 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalSeat(o, key) {
-    if (!Object.hasOwn(o, key))
-        return { state: 'absent' };
-    const value = o[key];
+    const value = ownDataField(o, key);
     return value === undefined ? { state: 'absent' } : { state: 'value', value };
 }
 export function projectCenterWiringCapability(caps) {
@@ -20,16 +19,16 @@ export function projectCenterWiringCapability(caps) {
 function projectCenterWiringOf(caps) {
     if (!isPlainObject(caps))
         return undefined;
-    const cw = Object.hasOwn(caps, 'centerWiring') ? caps.centerWiring : undefined;
+    const cw = ownDataField(caps, 'centerWiring');
     if (cw === undefined)
-        return capsGenerationOf(caps).generation === 'new' ? { kind: 'none' } : { kind: 'not_reported' };
+        return { kind: 'none' };
     if (!isPlainObject(cw))
         return undefined;
-    const effectivePull = cw.effectivePull;
-    const revisionRaw = cw.effectiveRevision;
-    const lease = cw.lease;
-    const usageReport = cw.usageReport;
-    const issuer = cw.issuer;
+    const effectivePull = ownDataField(cw, 'effectivePull');
+    const revisionRaw = ownDataField(cw, 'effectiveRevision');
+    const lease = ownDataField(cw, 'lease');
+    const usageReport = ownDataField(cw, 'usageReport');
+    const issuer = ownDataField(cw, 'issuer');
     if (typeof effectivePull !== 'boolean' || typeof usageReport !== 'boolean')
         return undefined;
     if (!nonEmpty(lease) || !nonEmpty(issuer))
@@ -41,8 +40,8 @@ function projectCenterWiringOf(caps) {
     else {
         if (!isPlainObject(revisionRaw))
             return undefined;
-        const version = revisionRaw.version;
-        const updatedAt = revisionRaw.updatedAt;
+        const version = ownDataField(revisionRaw, 'version');
+        const updatedAt = ownDataField(revisionRaw, 'updatedAt');
         if (typeof version !== 'number' || !Number.isFinite(version) || !nonEmpty(updatedAt))
             return undefined;
         effectiveRevision = { version, updatedAt };
@@ -58,7 +57,7 @@ function projectCenterWiringOf(caps) {
     if (callerSeat.state === 'value') {
         if (!isPlainObject(callerSeat.value))
             return undefined;
-        const callerLease = callerSeat.value.lease;
+        const callerLease = ownDataField(callerSeat.value, 'lease');
         if (!nonEmpty(callerLease))
             return undefined;
         const wait = optionalSeat(callerSeat.value, 'retryAfterSec');
@@ -66,6 +65,9 @@ function projectCenterWiringOf(caps) {
             return undefined;
         caller = { lease: callerLease, ...(wait.state === 'value' ? { retryAfterSec: wait.value } : {}) };
     }
+    const workerSeat = optionalSeat(cw, 'worker');
+    if (workerSeat.state === 'value' && !nonEmpty(workerSeat.value))
+        return undefined;
     return {
         kind: 'present',
         view: {
@@ -77,6 +79,7 @@ function projectCenterWiringOf(caps) {
             usageReport,
             issuer,
             ...(caller !== undefined ? { caller } : {}),
+            ...(workerSeat.state === 'value' ? { worker: workerSeat.value } : {}),
         },
     };
 }
@@ -96,7 +99,7 @@ function guarded(reading) {
         return undefined;
     try {
         const kind = reading.kind;
-        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'none')
+        if (kind === 'unobserved' || kind === 'none')
             return { kind };
         if (kind !== 'present')
             return undefined;
@@ -158,9 +161,6 @@ function failModeClause(v) {
 export function centerWiringDoctorDetail(reading) {
     const unobserved = 'center wiring not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this engine is connected to a configuration center is unknown';
     const r = guarded(reading);
-    if (r?.kind === 'not_reported') {
-        return 'center wiring not reported by this engine; this does not say whether the engine is connected to a configuration center';
-    }
     if (r?.kind === 'none') {
         return 'no configuration center on this deployment — the engine runs on its own local configuration; no quota lease or usage reporting goes through a center';
     }
@@ -194,9 +194,6 @@ export function centerWiringDoctorDetail(reading) {
         return unobserved;
     }
 }
-export function forgetCenterWiringReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetCenterWiringReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/classifierStatus.js

@@ -1,4 +1,5 @@
 import { classifierDenyCauseOf } from './autoModeUnavailable.js';
+import { readAskOrigin } from './ownKey.js';
 export const CLASSIFIER_STATUS_STATES = Object.freeze([
     'armed',
     'available',
@@ -8,14 +9,13 @@ const CLASSIFIER_RAN_ORIGINS = new Set(['denial_limit_fallback']);
 function askOriginOf(ask) {
     if (typeof ask !== 'object' || ask === null || Array.isArray(ask))
         return undefined;
-    const top = ask.origin;
-    if (typeof top === 'string' && top.length > 0)
+    const top = readAskOrigin(ask);
+    if (top !== undefined)
         return top;
     const gate = ask.gate;
     if (typeof gate !== 'object' || gate === null || Array.isArray(gate))
         return undefined;
-    const inner = gate.origin;
-    return typeof inner === 'string' && inner.length > 0 ? inner : undefined;
+    return readAskOrigin(gate);
 }
 const NOT_A_ROUND_FAILURE = new Set(['parse_error']);
 export function classifierStatusOf(autoMode, ask) {

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/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/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;