@sema-agent/client-core 0.91.0 → 0.93.0

package/dist/detachWire.js

@@ -1,60 +1,14 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
-import { versionSupportsLimits } from './limitsWire.js';
 import { resolveWireAuth } from './engineWireSdk.js';
 export const DETACH_HEADER = 'x-detach-on-disconnect';
 export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
-export const DETACH_WIRE_MIN_ENGINE = [1, 196, 0];
-export const versionSupportsDetach = versionSupportsLimits;
 export function headlessDetachDisabledByEnv(env = hostEnv()) {
     return envFlagOff(env[HEADLESS_DETACH_ENV]);
 }
-export async function probeEngineDetachSupport(baseUrl, opts) {
-    const fetchImpl = opts?.fetchImpl ?? fetch;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? 1500);
-    try {
-        const res = await fetchImpl(`${baseUrl.replace(/\/+$/, '')}/health`, {
-            method: 'GET',
-            signal: controller.signal,
-        });
-        if (!res.ok)
-            return 'unknown';
-        const body = await res.json();
-        if (body === null || typeof body !== 'object' || Array.isArray(body))
-            return 'unknown';
-        if (!('version' in body))
-            return 'unsupported';
-        const version = body.version;
-        if (typeof version !== 'string' || !/^\d+\.\d+\.\d+/.test(version))
-            return 'unknown';
-        if (versionSupportsDetach(version))
-            return 'supported';
-        return 'unsupported';
-    }
-    catch {
-        return 'unknown';
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-export function detachSupportDisclosure(support) {
-    if (support !== 'unknown')
-        return undefined;
-    return 'could not confirm whether this engine supports detach (its /health did not answer usably); sending the detach header anyway — it is harmless on the wire, and a dead engine fails the request loudly';
-}
-export async function engineSupportsDetach(baseUrl, opts) {
-    return (await probeEngineDetachSupport(baseUrl, opts)) !== 'unsupported';
-}
-export async function resolveHeadlessDetach(baseUrl, env = hostEnv(), opts) {
+export async function resolveHeadlessDetach(_baseUrl, env = hostEnv(), _opts) {
     if (headlessDetachDisabledByEnv(env))
         return { on: false, reason: 'env-off' };
-    if (env.SEMA_ENGINE_URL) {
-        const ok = await engineSupportsDetach(baseUrl, opts);
-        if (!ok)
-            return { on: false, reason: 'old-engine' };
-    }
     return { on: true, reason: 'default-on' };
 }
 export const DETACH_DURABLE_OFF_400_ANCHOR = 'x-detach-on-disconnect requires a durable run';

package/dist/deviceExecutorManagementCapability.d.ts

@@ -2,12 +2,15 @@ export type DeviceExecutorManagementReading = {
     kind: 'unobserved';
 } | {
     kind: 'not_reported';
-    why: 'capability_absent' | 'management_absent';
+    why: 'capability_absent';
 } | {
     kind: 'lane_absent';
 } | {
     kind: 'present';
-    management: boolean;
+    management: 'present-true' | 'present-false' | 'absent';
+    protocolVersion?: number;
+    maxInflightPerDevice?: number;
+    wsPath?: string;
 };
 export declare function projectDeviceExecutorManagementCapability(caps: unknown): DeviceExecutorManagementReading | undefined;
 export declare function noteEngineCapsForDeviceExecutorManagement(baseUrl: string, caps: unknown, opts?: {
@@ -15,6 +18,7 @@ export declare function noteEngineCapsForDeviceExecutorManagement(baseUrl: strin
 }): void;
 export declare function observedDeviceExecutorManagement(baseUrl?: string | undefined): DeviceExecutorManagementReading;
 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,5 +1,9 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.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;
@@ -14,14 +18,28 @@ export function projectDeviceExecutorManagementCapability(caps) {
     if (d === null || typeof d !== 'object' || Array.isArray(d))
         return undefined;
     const o = d;
-    if (!Object.hasOwn(o, 'management'))
-        return { kind: 'not_reported', why: 'management_absent' };
-    const mgmt = o.management;
+    if (ownRead(o, 'enabled') !== true)
+        return undefined;
+    const mgmt = ownRead(o, 'management');
+    let management;
     if (mgmt === undefined)
-        return { kind: 'not_reported', why: 'management_absent' };
-    if (typeof mgmt !== 'boolean')
+        management = 'absent';
+    else if (mgmt === true)
+        management = 'present-true';
+    else if (mgmt === false)
+        management = 'present-false';
+    else
         return undefined;
-    return { kind: 'present', management: mgmt };
+    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',
@@ -35,26 +53,54 @@ export function observedDeviceExecutorManagement(baseUrl = engineWireTarget()?.b
     return reader.observed(baseUrl);
 }
 export function deviceManagementVerbsAvailable(reading) {
+    if (reading.kind === 'present') {
+        if (reading.management === 'present-true')
+            return 'yes';
+        if (reading.management === 'present-false')
+            return 'no';
+        return 'unknown';
+    }
+    if (reading.kind === 'lane_absent')
+        return 'no';
+    return 'unknown';
+}
+export function deviceLaneOpen(reading) {
     if (reading.kind === 'present')
-        return reading.management ? 'yes' : 'no';
+        return 'yes';
     if (reading.kind === 'lane_absent')
         return 'no';
     return 'unknown';
 }
+const WS_PATH_DETAIL_MAX = 64;
+function laneFactsSuffix(r) {
+    const parts = [];
+    if (r.protocolVersion !== undefined)
+        parts.push(`protocol ${r.protocolVersion}`);
+    if (r.maxInflightPerDevice !== undefined)
+        parts.push(`${r.maxInflightPerDevice} in flight per device`);
+    if (r.wsPath !== undefined)
+        parts.push(`ws path ${capForDisplay(r.wsPath, WS_PATH_DETAIL_MAX)}`);
+    return parts.length === 0 ? '' : ` (${parts.join(', ')})`;
+}
 export function deviceExecutorManagementDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'device management face not observed — the engine reports it on /v1/capabilities (deviceExecutor.management); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'device management face not observed — the engine reports it on /v1/capabilities (deviceExecutor.management); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
-            return reading.why === 'management_absent'
-                ? 'device management face not reported by this engine — the device lane is advertised but only newer engines say whether the /v1/devices management verbs exist; this does not say whether they exist, probe them directly'
-                : 'device executor capability not reported by this engine — only newer engines advertise the device lane at all; this does not say whether it exists';
+            return 'device executor capability not reported by this engine; this does not say whether a device lane exists';
         case 'lane_absent':
             return 'no device lane on this deployment — the /v1/devices management verbs are unavailable (capability.device_lane_required)';
-        case 'present':
-            return reading.management
-                ? 'device management face on — the /v1/devices management verbs are available on this engine'
-                : 'device lane on but the /v1/devices management verbs are off on this deployment';
+        case 'present': {
+            const facts = laneFactsSuffix(reading);
+            switch (reading.management) {
+                case 'present-true':
+                    return `device management face on — the /v1/devices management verbs are available on this engine${facts}`;
+                case 'present-false':
+                    return `device lane on but the /v1/devices management verbs are off on this deployment${facts}`;
+                case 'absent':
+                    return `device lane on, but this engine does not report the /v1/devices management face; this does not say whether the management verbs exist, probe them directly${facts}`;
+            }
+        }
     }
 }
 export function forgetDeviceExecutorManagementReading(baseUrl) {

package/dist/displayUntrusted.js

@@ -1,3 +1,4 @@
+import { SETTINGS_SECRET_LITERAL_RE } from './generated/settingsSchemaTables.js';
 export const REDACTION_MARKER_PREFIX = '\u00abredacted';
 const MARKER_RE = /^\u00abredacted(?::[a-z-]{1,16}){0,2}\u00bb$/;
 const REDACTED_USERINFO = '\u00abredacted:userinfo\u00bb';
@@ -26,7 +27,7 @@ function pushEdit(edits, src, start, end, text) {
 const UNIT_NONE = 0;
 const UNIT_SEQUENCE = 1;
 const UNIT_SINGLE = 2;
-const SECRET_LITERAL_RE = /^(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;
+const SECRET_LITERAL_RE = SETTINGS_SECRET_LITERAL_RE;
 const SCHEME_TOKEN_RE = /(?:^|[^A-Za-z0-9_-])(?:bearer|basic)[ \t]+\S{8,4096}/i;
 const JWT_RE = /(?:^|[^A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,2048}\.[A-Za-z0-9_-]{8,2048}\.[A-Za-z0-9_-]{4,2048}/i;
 function scanForSecretLiteral(s) {

package/dist/effectiveFacts.d.ts

@@ -7,15 +7,25 @@ export interface EffectiveReasoningView {
     endpoint: string;
     dropped?: true;
 }
+export type EffectiveMemoryProjectKey = {
+    readonly scope: string;
+    readonly absent?: never;
+} | {
+    readonly absent: string;
+    readonly scope?: never;
+};
+export interface EffectiveMemoryScopeRow {
+    scope: string;
+    origin: 'deployment' | 'request';
+    shadowed?: number;
+}
 export interface EffectiveMemoryScopesView {
     state: 'mounted' | 'memoryless' | 'none';
     reason?: string;
     contract?: 'v2' | 'legacy';
-    scopes: readonly {
-        scope: string;
-        origin: 'deployment' | 'request';
-    }[];
+    scopes: readonly EffectiveMemoryScopeRow[];
     writeScope: string | null;
+    projectKey?: EffectiveMemoryProjectKey;
     materializedResidue?: readonly string[];
 }
 export declare function readEffectiveReasoning(v: unknown): EffectiveReasoningView | undefined;

package/dist/effectiveFacts.js

@@ -1,4 +1,37 @@
 const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+const nonBlank = (v) => typeof v === 'string' && v.trim().length > 0;
+const UNREADABLE = Symbol('unreadable');
+const protectedRead = (o, key) => {
+    try {
+        return o[key];
+    }
+    catch {
+        return UNREADABLE;
+    }
+};
+function readProjectKey(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const o = v;
+        const scope = protectedRead(o, 'scope');
+        const absent = protectedRead(o, 'absent');
+        if (scope === UNREADABLE || absent === UNREADABLE)
+            return undefined;
+        if ((scope === undefined) === (absent === undefined))
+            return undefined;
+        if (scope !== undefined)
+            return nonBlank(scope) ? { scope } : undefined;
+        return nonBlank(absent) ? { absent } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readShadowed(r, isWriteHome) {
+    const n = protectedRead(r, 'shadowed');
+    return !isWriteHome && typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? n : undefined;
+}
 export function readEffectiveReasoning(v) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -27,7 +60,8 @@ export function readEffectiveMemoryScopes(v) {
         return undefined;
     if (!Array.isArray(o.scopes))
         return undefined;
-    if (o.writeScope !== null && typeof o.writeScope !== 'string')
+    const writeScope = o.writeScope;
+    if (writeScope !== null && typeof writeScope !== 'string')
         return undefined;
     const contract = o.contract === 'v2' || o.contract === 'legacy' ? o.contract : undefined;
     const reason = nonEmpty(o.reason) ? o.reason : undefined;
@@ -39,13 +73,19 @@ export function readEffectiveMemoryScopes(v) {
             if (typeof row !== 'object' || row === null)
                 continue;
             const r = row;
-            if (!nonEmpty(r.scope) || typeof r.origin !== 'string' || !ORIGINS.has(r.origin))
+            const scope = r.scope;
+            if (!nonEmpty(scope))
+                continue;
+            const origin = r.origin;
+            if (typeof origin !== 'string' || !ORIGINS.has(origin))
                 continue;
-            scopes.push({ scope: r.scope, origin: r.origin });
+            const shadowed = readShadowed(r, scope === writeScope);
+            scopes.push({ scope, origin: origin, ...(shadowed !== undefined ? { shadowed } : {}) });
         }
-        return { state: 'mounted', contract, scopes, writeScope: o.writeScope };
+        const projectKey = readProjectKey(protectedRead(o, 'projectKey'));
+        return { state: 'mounted', contract, scopes, writeScope, ...(projectKey !== undefined ? { projectKey } : {}) };
     }
-    if (o.scopes.length !== 0 || o.writeScope !== null)
+    if (o.scopes.length !== 0 || writeScope !== null)
         return undefined;
     if (o.state === 'memoryless') {
         if (reason !== 'mount-failed' && reason !== 'no-backend')

package/dist/engineAgentAbsence.js

@@ -2,6 +2,7 @@ import { registryClockNowMs, registryListingProvenanceOf } from './agentSession/
 import { displayUntrusted } from './displayUntrusted.js';
 import { ABSENT_SETTLE_MS } from './fleetAgentPanelProjection.js';
 import { isEnginePanelTaskResident, isStaleEngineAgentPanelEnd, } from './engineAgentPanelStore.js';
+import { CORE_DURABLE_AGENT_HANDLE_RE } from './generated/engineFactTables.js';
 export const ENGINE_AGENT_ABSENT_ROW_TEXT = 'engine no longer reports this agent · it may still be running';
 export const ENGINE_AGENT_ABSENCE_TTL_MS = 30 * 60_000;
 function effectiveTtl(ttlMs) {
@@ -132,7 +133,7 @@ export function engineAgentTerminalAfterDropLine(label, status, hasReport) {
     return `${displayUntrusted(label)} reported ${displayUntrusted(status)} after it was dropped from the task panel${tail}`;
 }
 const REGISTRY_LIST_LIMIT = 500;
-const REGISTRY_AGENT_HANDLE_RE = /^a[0-9a-f]{6,32}$/;
+const REGISTRY_AGENT_HANDLE_RE = CORE_DURABLE_AGENT_HANDLE_RE;
 const REGISTRY_AGENT_TYPE = 'background_agent';
 function registryStatusReading(status) {
     const s = status;

package/dist/engineCapReader.js

@@ -1,4 +1,5 @@
 import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { capsGenerationMarkOf, retainCapsGenerationMark } from './engineCapsCache.js';
 function freezeReading(reading, seen = new Set()) {
     if (reading === null || typeof reading !== 'object' || seen.has(reading))
         return reading;
@@ -11,7 +12,7 @@ function freezeReading(reading, seen = new Set()) {
     return reading;
 }
 export function createEngineCapReader(spec) {
-    const readingByBase = new Map();
+    const cellByBase = new Map();
     return {
         note(baseUrl, caps, opts) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
@@ -21,6 +22,7 @@ export function createEngineCapReader(spec) {
                 return;
             if (!capsGenerationStillCurrent(baseUrl, gen))
                 return;
+            const mark = retainCapsGenerationMark(baseUrl);
             let reading;
             try {
                 reading = spec.project(caps);
@@ -28,29 +30,33 @@ export function createEngineCapReader(spec) {
             catch {
                 reading = undefined;
             }
-            if (!capsGenerationStillCurrent(baseUrl, gen))
+            if (capsGenerationMarkOf(baseUrl) !== mark)
                 return;
             if (reading === undefined) {
-                readingByBase.delete(baseUrl);
+                cellByBase.delete(baseUrl);
                 return;
             }
-            readingByBase.set(baseUrl, freezeReading(reading));
+            cellByBase.set(baseUrl, { reading: freezeReading(reading), mark });
         },
         observed(baseUrl) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
                 return spec.makeUnobserved();
-            const hit = readingByBase.get(baseUrl);
-            if (hit !== undefined)
-                return hit;
-            return spec.makeUnobserved();
+            const cell = cellByBase.get(baseUrl);
+            if (cell === undefined)
+                return spec.makeUnobserved();
+            if (cell.mark !== capsGenerationMarkOf(baseUrl)) {
+                cellByBase.delete(baseUrl);
+                return spec.makeUnobserved();
+            }
+            return cell.reading;
         },
         forget(baseUrl) {
             if (typeof baseUrl !== 'string' || baseUrl === '')
                 return;
-            readingByBase.delete(baseUrl);
+            cellByBase.delete(baseUrl);
         },
         __resetForTests() {
-            readingByBase.clear();
+            cellByBase.clear();
         },
     };
 }

package/dist/engineCapsCache.d.ts

@@ -1,4 +1,6 @@
 export declare function engineCapsGeneration(baseUrl: string): number;
+export declare function capsGenerationMarkOf(baseUrl: string): object | undefined;
+export declare function retainCapsGenerationMark(baseUrl: string): object;
 export declare function kickEngineCapsProbe(baseUrl: string, probe: () => Promise<unknown>): void;
 export declare function engineCapsSettled(baseUrl: string | undefined, opts?: {
     withinMs?: number;

package/dist/engineCapsCache.js

@@ -3,11 +3,22 @@ const inFlight = new Set();
 const settleByBase = new Map();
 const genByBase = new Map();
 function capsGeneration(baseUrl) {
-    return genByBase.get(baseUrl) ?? 0;
+    return genByBase.get(baseUrl)?.n ?? 0;
 }
 export function engineCapsGeneration(baseUrl) {
     return capsGeneration(baseUrl);
 }
+export function capsGenerationMarkOf(baseUrl) {
+    return genByBase.get(baseUrl);
+}
+export function retainCapsGenerationMark(baseUrl) {
+    let mark = genByBase.get(baseUrl);
+    if (mark === undefined) {
+        mark = Object.freeze({ n: 0 });
+        genByBase.set(baseUrl, mark);
+    }
+    return mark;
+}
 export function kickEngineCapsProbe(baseUrl, probe) {
     if (!baseUrl || capsByBase.has(baseUrl) || inFlight.has(baseUrl))
         return;
@@ -165,7 +176,7 @@ export function invalidateEngineCaps(baseUrl, probe) {
         settleByBase.has(baseUrl) ||
         genByBase.has(baseUrl);
     if (hadState) {
-        genByBase.set(baseUrl, capsGeneration(baseUrl) + 1);
+        genByBase.set(baseUrl, Object.freeze({ n: capsGeneration(baseUrl) + 1 }));
         capsByBase.delete(baseUrl);
         inFlight.delete(baseUrl);
         settleByBase.get(baseUrl)?.wake();

package/dist/engineConfigDrift.d.ts

@@ -0,0 +1,20 @@
+import type { HealthResponse } from './types/engineState.js';
+export interface EngineConfigApplyState {
+    readonly configTargetOrdinal: number;
+    readonly configAppliedOrdinal: number;
+    readonly configTargetVersion?: number;
+    readonly configAppliedVersion?: number;
+    readonly configApplyStaleMs?: number;
+}
+export declare function readEngineConfigApplyState(health: unknown): EngineConfigApplyState | null;
+export type ConfigDriftVerdict = 'skip' | 'in-sync' | 'ask' | 'advance-baseline';
+export interface ConfigDriftHealthView extends Pick<HealthResponse, 'configHash' | 'instanceId' | 'restartRequired'> {
+    configTargetOrdinal?: number | undefined;
+    configAppliedOrdinal?: number | undefined;
+}
+export interface ConfigDriftInput {
+    baselineConfigHash?: string | undefined;
+    baselineInstanceId?: string | undefined;
+    health?: ConfigDriftHealthView | undefined;
+}
+export declare function configDriftVerdict(input: ConfigDriftInput): ConfigDriftVerdict;

package/dist/engineConfigDrift.js

@@ -0,0 +1,54 @@
+function countOf(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined;
+}
+function ownValue(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && 'value' in d ? d.value : undefined;
+}
+export function readEngineConfigApplyState(health) {
+    try {
+        if (typeof health !== 'object' || health === null || Array.isArray(health))
+            return null;
+        const configTargetOrdinal = countOf(ownValue(health, 'configTargetOrdinal'));
+        const configAppliedOrdinal = countOf(ownValue(health, 'configAppliedOrdinal'));
+        if (configTargetOrdinal === undefined || configAppliedOrdinal === undefined)
+            return null;
+        const configTargetVersion = countOf(ownValue(health, 'configTargetVersion'));
+        const configAppliedVersion = countOf(ownValue(health, 'configAppliedVersion'));
+        const configApplyStaleMs = countOf(ownValue(health, 'configApplyStaleMs'));
+        return {
+            configTargetOrdinal,
+            configAppliedOrdinal,
+            ...(configTargetVersion !== undefined && configAppliedVersion !== undefined ? { configTargetVersion, configAppliedVersion } : {}),
+            ...(configApplyStaleMs !== undefined ? { configApplyStaleMs } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function configDriftVerdict(input) {
+    try {
+        const { baselineConfigHash, baselineInstanceId, health } = input;
+        const view = typeof health === 'object' && health !== null ? health : undefined;
+        if (view !== undefined && ownValue(view, 'restartRequired') === true)
+            return 'ask';
+        const hashRaw = view === undefined ? undefined : ownValue(view, 'configHash');
+        const nowHash = typeof hashRaw === 'string' ? hashRaw : undefined;
+        if (!baselineConfigHash || !nowHash)
+            return 'skip';
+        if (nowHash === baselineConfigHash)
+            return 'in-sync';
+        const instanceRaw = view === undefined ? undefined : ownValue(view, 'instanceId');
+        const nowInstance = typeof instanceRaw === 'string' ? instanceRaw : undefined;
+        if (!baselineInstanceId || !nowInstance || nowInstance !== baselineInstanceId)
+            return 'ask';
+        const apply = readEngineConfigApplyState(view);
+        if (apply === null)
+            return 'ask';
+        return apply.configTargetOrdinal === apply.configAppliedOrdinal ? 'advance-baseline' : 'ask';
+    }
+    catch {
+        return 'ask';
+    }
+}

package/dist/engineErrorCodes.d.ts

@@ -14,6 +14,8 @@ export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_cap
 export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project_key_spelling";
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
+export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
+export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
 export declare const CONFIG_REFUSAL_CODES: ReadonlySet<string>;
 export declare const RULES_LEGACY_TOOL_NAME = "rules.legacy_tool_name";
 export declare function isRulesRefusalCode(code: string | undefined): boolean;
@@ -63,16 +65,31 @@ export declare const RESUME_REOPEN_CODES: readonly string[];
 export declare const PARKED_RESUME_STARTUP_FAILED = "parked_resume.startup_failed";
 export declare const DECIDE_WORKFLOW_HOST_UNKNOWN = "decide.workflow_host_unknown";
 export declare const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = "decide.workflow_remember_unsupported";
+export declare const DECIDE_WORKFLOW_PARK_FORKED = "decide.workflow_park_forked";
+export declare const DECIDE_WORKFLOW_PARKS_UNREADABLE = "decide.workflow_parks_unreadable";
 export declare const DECIDE_WORKFLOW_LANE_CODES: readonly string[];
 export declare const DECIDE_NOT_PARKED = "decide.not_parked";
 export declare const DECIDE_GATE_MOVED = "decide.gate_moved";
 export declare const DECIDE_CLAIM_LOST = "decide.claim_lost";
 export declare const DECIDE_PARK_MOVED_CODES: readonly string[];
 export declare function isDecideParkMovedCode(code: string | null | undefined): boolean;
+export declare const ASK_GONE = "gone.ask";
+export declare const ASK_GONE_DENIED_WORD = "routing_failure_fail_closed";
+export declare const RUN_STALLED = "run.stalled";
+export declare const RUN_ORPHANED = "run.orphaned";
+export declare const APPROVAL_EXPIRED = "approval.expired";
+export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
+export type RunDeathVerdictCode = (typeof RUN_DEATH_VERDICT_CODES)[number];
+export declare function runDeathVerdictNoteOf(code: string | undefined): string | undefined;
+export declare const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = "capability.operator_principals_required";
+export declare function isUnavailableFaceCode(code: string | undefined): boolean;
+export type OperatorGateRefusal = 'operator_only' | 'operators_unconfigured';
+export declare function operatorGateRefusalContent(cause: OperatorGateRefusal): string | undefined;
 export declare const WORKFLOW_PARK_REFUSAL_CODES: readonly string[];
 export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";
 export declare const SCENARIO_NOT_ALLOWED_ERROR_CODE = "scenario_not_allowed";
+export declare const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = "state.scenario_assignment_unknown";
 export declare const STREAM_MAX_DURATION = "STREAM_MAX_DURATION";
 export type ModelFallbackReason = 'inherit_no_tier_binding';
 export declare const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING: ModelFallbackReason;

package/dist/engineErrorCodes.js

@@ -19,6 +19,12 @@ export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
 export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spelling';
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
+export const CONFIG_IMAGE_INVALID = 'config.image_invalid';
+const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with the message was refused before the model was called — the engine’s own error text says which image and what is wrong with it. ' +
+    'Nothing was sent to the model; remove or replace that image, then send the message again.';
+export function imageInvalidFailureNoteOf(code) {
+    return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
+}
 export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_LIMIT_INVALID,
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
@@ -28,6 +34,7 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_MEMORY_PROJECT_KEY_SPELLING,
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
     CONFIG_LEGACY_TOOL_NAME,
+    CONFIG_IMAGE_INVALID,
     ...CORE_TOOL_DECLARATION_CODES,
 ]);
 export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
@@ -134,9 +141,13 @@ export const RESUME_REOPEN_CODES = Object.freeze([
 export const PARKED_RESUME_STARTUP_FAILED = 'parked_resume.startup_failed';
 export const DECIDE_WORKFLOW_HOST_UNKNOWN = 'decide.workflow_host_unknown';
 export const DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED = 'decide.workflow_remember_unsupported';
+export const DECIDE_WORKFLOW_PARK_FORKED = 'decide.workflow_park_forked';
+export const DECIDE_WORKFLOW_PARKS_UNREADABLE = 'decide.workflow_parks_unreadable';
 export const DECIDE_WORKFLOW_LANE_CODES = Object.freeze([
     DECIDE_WORKFLOW_HOST_UNKNOWN,
     DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED,
+    DECIDE_WORKFLOW_PARKS_UNREADABLE,
+    DECIDE_WORKFLOW_PARK_FORKED,
 ]);
 export const DECIDE_NOT_PARKED = 'decide.not_parked';
 export const DECIDE_GATE_MOVED = 'decide.gate_moved';
@@ -149,6 +160,39 @@ export const DECIDE_PARK_MOVED_CODES = Object.freeze([
 export function isDecideParkMovedCode(code) {
     return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
 }
+export const ASK_GONE = 'gone.ask';
+export const ASK_GONE_DENIED_WORD = 'routing_failure_fail_closed';
+export const RUN_STALLED = 'run.stalled';
+export const RUN_ORPHANED = 'run.orphaned';
+export const APPROVAL_EXPIRED = 'approval.expired';
+export const RUN_DEATH_VERDICT_CODES = Object.freeze([RUN_STALLED, RUN_ORPHANED, APPROVAL_EXPIRED]);
+const RUN_HOLDER_LOST_OUTLET = 'The request itself was not at fault, but this run cannot be picked up again; submit the work again as a new task.';
+const RUN_ORPHANED_NOTE = 'This run ended because the engine process that was running it went away (it was restarted) before the run finished. ' + RUN_HOLDER_LOST_OUTLET;
+const RUN_STALLED_NOTE = 'This run ended because the engine process that was running it stopped reporting in before the run finished. ' + RUN_HOLDER_LOST_OUTLET;
+const RUN_APPROVAL_EXPIRED_NOTE = 'This run ended because it was waiting on an approval for too long and the engine retired it. ' +
+    'The request itself was not at fault, but this run cannot be picked up again; submit the work again as a new task, and it will ask for the approval again.';
+export function runDeathVerdictNoteOf(code) {
+    if (code === RUN_ORPHANED)
+        return RUN_ORPHANED_NOTE;
+    if (code === RUN_STALLED)
+        return RUN_STALLED_NOTE;
+    if (code === APPROVAL_EXPIRED)
+        return RUN_APPROVAL_EXPIRED_NOTE;
+    return undefined;
+}
+export const CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED = 'capability.operator_principals_required';
+export function isUnavailableFaceCode(code) {
+    return typeof code === 'string' && (code.startsWith('capability.') || code.startsWith('feature.'));
+}
+export function operatorGateRefusalContent(cause) {
+    if (cause === 'operator_only') {
+        return 'Nothing was done: this is an operator-only action and the caller is not one of this deployment’s operators.';
+    }
+    if (cause === 'operators_unconfigured') {
+        return 'Nothing was done: this is an operator-only action and this deployment has no operators configured, so no caller can perform it here — whoever runs the deployment has to name its operators first.';
+    }
+    return undefined;
+}
 const WORKFLOW_PARK_TRUTH_UNREADABLE = 'workflow.park_truth_unreadable';
 const WORKFLOW_PARK_NOT_PENDING = 'workflow.park_not_pending';
 const WORKFLOW_PARK_BINDING_BROKEN = 'workflow.park_binding_broken';
@@ -165,6 +209,7 @@ export function isWorkflowParkRefusalCode(code) {
 }
 export const DRAINING_ERROR_CODE = 'draining';
 export const SCENARIO_NOT_ALLOWED_ERROR_CODE = 'scenario_not_allowed';
+export const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = 'state.scenario_assignment_unknown';
 export const STREAM_MAX_DURATION = 'STREAM_MAX_DURATION';
 export const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING = 'inherit_no_tier_binding';
 export function asModelFallbackReason(v) {

package/dist/engineInlineTaskStats.d.ts

@@ -4,6 +4,7 @@ export interface EngineInlineTaskStats {
     totalTokens: number;
     durationMs: number;
     currentAction?: string;
+    model?: string;
     done: boolean;
     isError: boolean;
 }