@sema-agent/client-core 0.111.0 → 0.112.0

package/dist/decideReceipt.d.ts

@@ -1,5 +1,6 @@
 import { type GateOutcomeView } from './gateOutcome.js';
 import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
+import { ASK_GONE } from './engineErrorCodes.js';
 import { type CrashConvergedRowReading } from './hitl/crashConverged.js';
 import type { AskRowEndingCause } from '@sema-agent/sdk';
 import { SDK_DECIDE_BINDING_KEYS } from './generated/sdkFactTables.js';
@@ -41,7 +42,7 @@ export interface DecideRequiresBindingDetail {
 export declare function decideRequiresBindingFromError(e: {} | null | undefined): DecideRequiresBindingDetail | null;
 export declare function decideRequiresBindingContent(_detail?: DecideRequiresBindingDetail, lang?: UiLanguage | (string & {})): string;
 export interface AskGoneDetail {
-    code: 'gone.ask';
+    code: typeof ASK_GONE;
     state?: 'VOID' | 'DENIED';
     endingCause?: AskRowEndingCause;
     holderGone?: CrashConvergedRowReading['cause'];

package/dist/deviceRebind.js

@@ -1,5 +1,6 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readOwnDataValue } from './ownKey.js';
+import { LIMIT_RATE_EXCEEDED } from './engineErrorCodes.js';
 import { isDisplayableWireCode, readErrorString, readErrorStrictStringList, readThrownSlot, wireFailureShapeOf } from './wireFailureShape.js';
 import { EXECUTION_PLACEMENT_DEVICE_LANE, EXECUTION_PLACEMENT_ROLES } from './executionPlacementWords.js';
 const LANE_ABSENT = 'capability.device_lane_required';
@@ -308,7 +309,6 @@ export function rebindProvesRequestNotApplied(outcome) {
             return false;
     }
 }
-const RATE_LIMITED = 'limit.rate_exceeded';
 const ENROLLMENT_INVALID = 'device.enrollment_invalid';
 function rateLimitedOf(e) {
     const sec = wireFailureShapeOf(e).retryAfterSec;
@@ -329,7 +329,7 @@ function issueFailureOf(e) {
     const common = commonOf(v.status, v.code);
     if (common !== null)
         return common.kind === 'not-found' ? refusedOf(404, NOT_FOUND, e) : common;
-    if (v.status === 429 && v.code === RATE_LIMITED)
+    if (v.status === 429 && v.code === LIMIT_RATE_EXCEEDED)
         return rateLimitedOf(e);
     return v.status !== undefined ? refusedOf(v.status, v.code, e) : transportOf(v);
 }
@@ -359,7 +359,7 @@ function enrollFailureOf(e, token) {
         return common.kind === 'not-found' ? refusedOf(404, NOT_FOUND, e, token) : common;
     if (v.status === 403 && v.code === ENROLLMENT_INVALID)
         return { kind: 'enrollment-invalid' };
-    if (v.status === 429 && v.code === RATE_LIMITED)
+    if (v.status === 429 && v.code === LIMIT_RATE_EXCEEDED)
         return rateLimitedOf(e);
     if (v.status === 503 && v.code === SERVICE_TOKEN_REQUIRED)
         return refusedOf(v.status, v.code, e, token);

package/dist/effectiveFacts.d.ts

@@ -30,3 +30,12 @@ export interface EffectiveMemoryScopesView {
 }
 export declare function readEffectiveReasoning(v: unknown): EffectiveReasoningView | undefined;
 export declare function readEffectiveMemoryScopes(v: unknown): EffectiveMemoryScopesView | undefined;
+export type ReadDenyFloorReading = {
+    readonly kind: 'unkept';
+    readonly message: string;
+} | {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function readDenyFloorOf(result: {} | null | undefined): ReadDenyFloorReading;

package/dist/effectiveFacts.js

@@ -1,3 +1,4 @@
+import { READ_DENY_FLOOR_UNKEPT } from './engineErrorCodes.js';
 const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
 const nonBlank = (v) => typeof v === 'string' && v.trim().length > 0;
 const UNREADABLE = Symbol('unreadable');
@@ -104,3 +105,35 @@ export function readEffectiveMemoryScopes(v) {
         return undefined;
     return { state: 'none', reason, scopes: [], writeScope: null };
 }
+const DENY_FLOOR_NOT_REPORTED = Object.freeze({ kind: 'not_reported' });
+const DENY_FLOOR_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+function ownSlotOf(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    if (d === undefined)
+        return { absent: true };
+    if (!Object.hasOwn(d, 'value'))
+        throw new TypeError('accessor');
+    return { absent: false, value: d.value };
+}
+export function readDenyFloorOf(result) {
+    try {
+        if (typeof result !== 'object' || result === null)
+            return DENY_FLOOR_NOT_REPORTED;
+        const slot = ownSlotOf(result, 'readDenyFloor');
+        if (slot.absent || slot.value === undefined)
+            return DENY_FLOOR_NOT_REPORTED;
+        const v = slot.value;
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return DENY_FLOOR_UNREADABLE;
+        const code = ownSlotOf(v, 'code');
+        const message = ownSlotOf(v, 'message');
+        if (code.absent || code.value !== READ_DENY_FLOOR_UNKEPT)
+            return DENY_FLOOR_UNREADABLE;
+        if (message.absent || typeof message.value !== 'string' || message.value.length === 0)
+            return DENY_FLOOR_UNREADABLE;
+        return Object.freeze({ kind: 'unkept', message: message.value });
+    }
+    catch {
+        return DENY_FLOOR_UNREADABLE;
+    }
+}

package/dist/engineAddress.d.ts

@@ -1,3 +1,4 @@
+export declare function hasUnsafeAddressCharacter(s: string): boolean;
 export declare function tupleOriginUrlOf(raw: string): URL | undefined;
 export declare function carriesNoCredentialSlots(u: URL): boolean;
 export declare function isCenterRelativePath(path: string): boolean;

package/dist/engineAddress.js

@@ -1,3 +1,6 @@
+export function hasUnsafeAddressCharacter(s) {
+    return /[\s\u0000-\u001f\u007f-\u009f\\]/u.test(s);
+}
 export function tupleOriginUrlOf(raw) {
     try {
         const u = new URL(raw);
@@ -16,7 +19,7 @@ export function isCenterRelativePath(path) {
     const second = path.charCodeAt(1);
     if (second === 0x2f || second === 0x5c)
         return false;
-    if (/[\s\u0000-\u001f\u007f-\u009f\\?#]/u.test(path))
+    if (hasUnsafeAddressCharacter(path) || path.includes('?') || path.includes('#'))
         return false;
     return path.split('/').every((segment) => {
         const decoded = segment.replace(/%2e/gi, '.');

package/dist/engineCredentialRelease.d.ts

@@ -0,0 +1,54 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import { type EngineIdentityView } from './engineIdentity.js';
+import type { LocalEngineVerdict } from './localEngineJudge.js';
+type OwnershipMismatchWhich = Extract<LocalEngineVerdict, {
+    kind: 'stranger';
+}>['mismatch'];
+export type LocalEngineIdentityVerdict = {
+    readonly kind: 'match';
+    readonly identity: EngineIdentityView;
+    readonly provenAt?: number;
+} | {
+    readonly kind: 'mismatch';
+    readonly which: OwnershipMismatchWhich;
+} | {
+    readonly kind: 'unreadable';
+};
+export type EngineCredentialTransport = {
+    readonly reuse: 'none';
+    readonly fetch: typeof fetch;
+} | {
+    readonly reuse: 'generation';
+    readonly fetch: typeof fetch;
+    readonly boundTo: EngineIdentityView;
+    readonly openedAt: number;
+};
+export interface EngineCredentialReleaseInput {
+    readonly ownership: LocalEngineIdentityVerdict;
+    readonly transport?: EngineCredentialTransport;
+}
+export type EngineCredentialWithholdReason = 'ownership_unreadable' | 'ownership_mismatch' | 'transport_undeclared' | 'transport_predates_proof' | 'transport_generation_unreadable';
+export declare const ENGINE_CREDENTIAL_WITHHOLD_REASONS: readonly EngineCredentialWithholdReason[];
+export type EngineCredentialReleaseVerdict = {
+    readonly kind: 'present';
+    readonly identity: 'proven';
+} | {
+    readonly kind: 'withhold';
+    readonly identity: 'unproven';
+    readonly reason: EngineCredentialWithholdReason;
+    readonly retireTransport: boolean;
+};
+export interface LocalEngineWireClientConfig extends EngineCredentialReleaseInput {
+    readonly baseUrl: string;
+    readonly token?: string;
+    readonly principal?: string;
+    readonly timeoutMs?: number;
+    readonly maxRetries?: number;
+}
+export interface LocalEngineWireClient {
+    readonly client: AgentClient | null;
+    readonly release: EngineCredentialReleaseVerdict;
+}
+export declare function engineCredentialReleaseVerdictOf(input: EngineCredentialReleaseInput): EngineCredentialReleaseVerdict;
+export declare function makeLocalEngineWireClient(cfg: LocalEngineWireClientConfig): LocalEngineWireClient;
+export {};

package/dist/engineCredentialRelease.js

@@ -0,0 +1,146 @@
+import { engineIdentityOf, engineIdentityVerdict } from './engineIdentity.js';
+import { makeEngineWireClient } from './engineWireSdk.js';
+import { readOwnDataValue } from './ownKey.js';
+export const ENGINE_CREDENTIAL_WITHHOLD_REASONS = Object.freeze([
+    'ownership_unreadable',
+    'ownership_mismatch',
+    'transport_undeclared',
+    'transport_predates_proof',
+    'transport_generation_unreadable',
+]);
+const MISMATCH_WHICH = Object.freeze(['pid', 'generation', 'data-root']);
+const _whichIsJudgeVocabulary = [true, true];
+void _whichIsJudgeVocabulary;
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (!isRecord(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function identityOwn(v) {
+    return engineIdentityOf({ pid: own(v, 'pid'), instanceId: own(v, 'instanceId'), startedAt: own(v, 'startedAt') });
+}
+function isMoment(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0;
+}
+function globalFetch() {
+    try {
+        return globalThis.fetch;
+    }
+    catch {
+        return undefined;
+    }
+}
+function declaredFetch(t) {
+    const f = own(t, 'fetch');
+    return typeof f === 'function' && f !== globalFetch() ? f : undefined;
+}
+function reuseOf(t) {
+    if (declaredFetch(t) === undefined)
+        return undefined;
+    const r = own(t, 'reuse');
+    return r === 'none' || r === 'generation' ? r : undefined;
+}
+function withhold(reason, retireTransport) {
+    return Object.freeze({ kind: 'withhold', identity: 'unproven', reason, retireTransport });
+}
+function present() {
+    return Object.freeze({ kind: 'present', identity: 'proven' });
+}
+function judge(input) {
+    const ownership = own(input, 'ownership');
+    const transport = own(input, 'transport');
+    const reuse = reuseOf(transport);
+    const kind = own(ownership, 'kind');
+    if (kind === 'mismatch') {
+        const which = own(ownership, 'which');
+        return MISMATCH_WHICH.includes(which) ? withhold('ownership_mismatch', reuse === 'generation') : withhold('ownership_unreadable', false);
+    }
+    const identity = own(ownership, 'identity');
+    if (kind !== 'match' || !isRecord(identity))
+        return withhold('ownership_unreadable', false);
+    if (reuse === undefined)
+        return withhold('transport_undeclared', false);
+    if (reuse === 'none')
+        return present();
+    const boundTo = own(transport, 'boundTo');
+    const same = isRecord(boundTo) ? engineIdentityVerdict(identityOwn(boundTo), identityOwn(identity)) : 'unknown';
+    if (same === 'changed')
+        return withhold('transport_predates_proof', true);
+    const provenAt = own(ownership, 'provenAt');
+    const openedAt = own(transport, 'openedAt');
+    if (same !== 'same' || !isMoment(provenAt) || !isMoment(openedAt))
+        return withhold('transport_generation_unreadable', true);
+    return openedAt >= provenAt ? present() : withhold('transport_predates_proof', true);
+}
+export function engineCredentialReleaseVerdictOf(input) {
+    try {
+        return judge(input);
+    }
+    catch {
+        return withhold('ownership_unreadable', false);
+    }
+}
+function anchorsOf(v) {
+    if (!isRecord(v))
+        return undefined;
+    return Object.freeze({ pid: own(v, 'pid'), instanceId: own(v, 'instanceId'), startedAt: own(v, 'startedAt') });
+}
+function sampleRelease(cfg) {
+    try {
+        const o = own(cfg, 'ownership');
+        const t = own(cfg, 'transport');
+        const fetchImpl = declaredFetch(t);
+        const ownership = isRecord(o)
+            ? Object.freeze({ kind: own(o, 'kind'), which: own(o, 'which'), identity: anchorsOf(own(o, 'identity')), provenAt: own(o, 'provenAt') })
+            : undefined;
+        const transport = isRecord(t)
+            ? Object.freeze({ reuse: own(t, 'reuse'), fetch: fetchImpl, boundTo: anchorsOf(own(t, 'boundTo')), openedAt: own(t, 'openedAt') })
+            : undefined;
+        return Object.freeze({ input: Object.freeze({ ownership, transport }), fetchImpl });
+    }
+    catch {
+        return Object.freeze({ input: Object.freeze({ ownership: undefined, transport: undefined }), fetchImpl: undefined });
+    }
+}
+export function makeLocalEngineWireClient(cfg) {
+    const sample = sampleRelease(cfg);
+    const release = engineCredentialReleaseVerdictOf(sample.input);
+    let client = null;
+    try {
+        const baseUrl = own(cfg, 'baseUrl');
+        if (typeof baseUrl === 'string') {
+            const token = own(cfg, 'token');
+            const principal = own(cfg, 'principal');
+            const timeoutMs = own(cfg, 'timeoutMs');
+            const maxRetries = own(cfg, 'maxRetries');
+            const fetchImpl = sample.fetchImpl;
+            client = makeEngineWireClient({
+                baseUrl,
+                ...(release.kind === 'present' && fetchImpl !== undefined && typeof token === 'string' && token !== '' ? { token } : {}),
+                ...(typeof principal === 'string' ? { principal } : {}),
+                ...(typeof timeoutMs === 'number' ? { timeoutMs } : {}),
+                ...(typeof maxRetries === 'number' ? { maxRetries } : {}),
+                ...(fetchImpl !== undefined ? { fetchImpl } : {}),
+            });
+        }
+    }
+    catch {
+        client = null;
+    }
+    return Object.freeze({ client, release });
+}

package/dist/engineErrorCodes.d.ts

@@ -165,6 +165,7 @@ 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 READ_DENY_FLOOR_UNKEPT = "config.read_deny_floor_unkept";
 export declare const USER_ATTACHMENT_INVALID_ERROR_CODE = "config.user_attachment_invalid";
 export declare const USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE = "config.user_invoked_skill_unknown";
 export declare const STREAM_MAX_DURATION = "STREAM_MAX_DURATION";

package/dist/engineErrorCodes.js

@@ -306,6 +306,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 READ_DENY_FLOOR_UNKEPT = 'config.read_deny_floor_unkept';
 export const USER_ATTACHMENT_INVALID_ERROR_CODE = 'config.user_attachment_invalid';
 export const USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE = 'config.user_invoked_skill_unknown';
 export const STREAM_MAX_DURATION = 'STREAM_MAX_DURATION';

package/dist/engineHealthFacts.d.ts

@@ -1,5 +1,4 @@
 import type { HealthAuthKind } from '@sema-agent/sdk';
-import { type EngineHealthStoreDurability } from './storeDurabilityWord.js';
 export interface EngineHealthCenterFacts {
     readonly issuer?: string;
     readonly webBaseUrl?: string;
@@ -52,14 +51,4 @@ export type ModsDeploymentPackagesReading = {
     readonly kind: 'unreadable';
 };
 export declare function readModsDeploymentPackages(health: object | null | undefined): ModsDeploymentPackagesReading;
-export type EngineHealthStoreReading = {
-    readonly kind: 'reported';
-    readonly durability: EngineHealthStoreDurability;
-} | {
-    readonly kind: 'unreadable';
-    readonly word?: string;
-} | {
-    readonly kind: 'absent';
-};
-export declare function readEngineHealthStore(health: object | null | undefined): EngineHealthStoreReading;
 export declare function readEngineHealthFacts(health: object | null | undefined): EngineHealthFacts;

package/dist/engineHealthFacts.js

@@ -1,5 +1,4 @@
 import { ownDataField, readOwnDataValue } from './ownKey.js';
-import { readStoreDurability } from './storeDurabilityWord.js';
 const _healthFactsMatchSdk = [true, true, true, true, true, true, true, true, true, true];
 void _healthFactsMatchSdk;
 const ENGINE_SIGNAL_KEY = 'engineSignal';
@@ -138,26 +137,6 @@ export function readModsDeploymentPackages(health) {
         return Object.freeze({ kind: 'unreadable' });
     }
 }
-export function readEngineHealthStore(health) {
-    try {
-        if (!isObject(health))
-            return Object.freeze({ kind: 'unreadable' });
-        const store = ownDataField(health, 'store');
-        if (store === undefined)
-            return Object.freeze({ kind: 'absent' });
-        if (!isObject(store))
-            return Object.freeze({ kind: 'unreadable' });
-        const read = readStoreDurability(store);
-        if (read.kind === 'word')
-            return Object.freeze({ kind: 'reported', durability: read.durability });
-        if (read.kind === 'unrecognized')
-            return Object.freeze({ kind: 'unreadable', word: read.word });
-        return Object.freeze({ kind: 'unreadable' });
-    }
-    catch {
-        return Object.freeze({ kind: 'unreadable' });
-    }
-}
 export function readEngineHealthFacts(health) {
     if (!isObject(health))
         return Object.freeze({});

package/dist/engineHealthProbeVerdict.d.ts

@@ -19,5 +19,6 @@ export interface TimedHealthAnswer {
     readonly atMs: number;
 }
 export declare function classifyHealthProbe(reading: ProbeHealthResult): HealthProbeVerdict | undefined;
+export declare function healthProbeVerdictOf(v: {} | null | undefined): HealthProbeVerdict | undefined;
 export declare function healthAnswerClause(verdict: HealthProbeVerdict, lang?: UiLanguage): string | undefined;
 export declare function latestSegmentHealthAnswer(segmentStartMs: number | undefined, ...seen: ReadonlyArray<TimedHealthAnswer | undefined>): HealthProbeAnsweredNotOk | undefined;

package/dist/engineHealthProbeVerdict.js

@@ -56,25 +56,33 @@ function answeredNotOkOf(v) {
         return undefined;
     return answeredNotOk(reason, http, shownStatusOf(ownValue(v, 'status')));
 }
-export function healthAnswerClause(verdict, lang) {
+export function healthProbeVerdictOf(v) {
     try {
-        if (typeof verdict !== 'object' || verdict === null)
+        if (typeof v !== 'object' || v === null)
             return undefined;
-        const kind = ownValue(verdict, 'kind');
+        const kind = ownValue(v, 'kind');
         if (kind === 'answered_ok')
-            return renderMessage(msg('localEngine.health.answer.ok'), lang);
+            return Object.freeze({ kind: 'answered_ok' });
         if (kind === 'unanswered') {
-            const reason = ownValue(verdict, 'reason');
-            if (reason === 'timeout')
-                return renderMessage(msg('localEngine.health.answer.unansweredTimeout'), lang);
-            if (reason === 'network')
-                return renderMessage(msg('localEngine.health.answer.unansweredNetwork'), lang);
-            return undefined;
+            const reason = ownValue(v, 'reason');
+            return typeof reason === 'string' && UNANSWERED_REASONS.has(reason) ? Object.freeze({ kind: 'unanswered', reason: reason }) : undefined;
         }
-        const nok = answeredNotOkOf(verdict);
-        if (nok === undefined)
+        return answeredNotOkOf(v);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function healthAnswerClause(verdict, lang) {
+    try {
+        const v = healthProbeVerdictOf(verdict);
+        if (v === undefined)
             return undefined;
-        return renderMessage(msg(nok.reason === 'not_ok' ? 'localEngine.health.answer.notOkStatus' : 'localEngine.health.answer.notOkHttp', { http: nok.http }), lang);
+        if (v.kind === 'answered_ok')
+            return renderMessage(msg('localEngine.health.answer.ok'), lang);
+        if (v.kind === 'unanswered')
+            return renderMessage(msg(v.reason === 'timeout' ? 'localEngine.health.answer.unansweredTimeout' : 'localEngine.health.answer.unansweredNetwork'), lang);
+        return renderMessage(msg(v.reason === 'not_ok' ? 'localEngine.health.answer.notOkStatus' : 'localEngine.health.answer.notOkHttp', { http: v.http }), lang);
     }
     catch {
         return undefined;

package/dist/engineUnavailable.d.ts

@@ -1,6 +1,7 @@
 import type { RequestLane } from './request/taskRequest.js';
 import type { UiLanguage } from './env/uiLanguage.js';
-export declare const ENGINE_UNAVAILABLE_REASONS: readonly ["not_running", "not_answering", "address_refused", "version_refused", "model_setup", "credential_conflict", "credential_refused", "data_root_refused"];
+import { type HealthProbeVerdict } from './engineHealthProbeVerdict.js';
+export declare const ENGINE_UNAVAILABLE_REASONS: readonly ["not_running", "not_answering", "address_refused", "version_refused", "model_setup", "credential_conflict", "credential_refused", "data_root_refused", "previous_not_stopped"];
 export type EngineUnavailableReason = (typeof ENGINE_UNAVAILABLE_REASONS)[number];
 export type EngineBootRefusalReason = Extract<EngineUnavailableReason, 'model_setup' | 'credential_conflict' | 'credential_refused' | 'data_root_refused'>;
 export declare const ENGINE_INSTALL_SHAPES: readonly ["npm-global", "managed", "npm-local", "dev", "app", "unknown"];
@@ -38,7 +39,7 @@ export interface EngineUnavailableFacts {
     readonly engineExitCode?: number | null;
     readonly engineSignal?: string | null;
     readonly pid?: number;
-    readonly answer?: 'silent' | 'answered' | 'drain-stuck';
+    readonly answer?: HealthProbeVerdict;
     readonly form?: EngineBootRefusalForm;
 }
 export declare function engineUnavailableLine(facts: EngineUnavailableFacts, lane: RequestLane, lang?: UiLanguage): string | undefined;

package/dist/engineUnavailable.js

@@ -3,6 +3,7 @@ import { compareReleaseVersions } from './supportFloor.js';
 import { LOCAL_ENGINE_SPAWN_ENV } from './localEngineSpawn.js';
 import { SETTINGS_MODEL_PLANE_REFUSAL_CODES, SETTINGS_WEB_ADMIN_TOKEN_ENV } from './generated/settingsSchemaTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { healthProbeVerdictOf } from './engineHealthProbeVerdict.js';
 export const ENGINE_UNAVAILABLE_REASONS = Object.freeze([
     'not_running',
     'not_answering',
@@ -12,6 +13,7 @@ export const ENGINE_UNAVAILABLE_REASONS = Object.freeze([
     'credential_conflict',
     'credential_refused',
     'data_root_refused',
+    'previous_not_stopped',
 ]);
 export const ENGINE_INSTALL_SHAPES = Object.freeze(['npm-global', 'managed', 'npm-local', 'dev', 'app', 'unknown']);
 const SCHEMA_MISMATCH_CODE = 'config.schema_mismatch';
@@ -345,8 +347,9 @@ function armFix(reason, retry, facts, form) {
                 return msg('engine.unavailable.fix.credentialMultiTenant', { again, token: SETTINGS_WEB_ADMIN_TOKEN_ENV.token, tokenFile: SETTINGS_WEB_ADMIN_TOKEN_ENV.tokenFile });
             }
             return msg('engine.unavailable.fix.credential', { again });
-        case 'not_answering': {
-            const wait = msg(facts.answer === 'silent' ? 'engine.unavailable.wait.respond' : facts.answer === 'drain-stuck' ? 'engine.unavailable.wait.exit' : 'engine.unavailable.wait.healthy');
+        case 'not_answering':
+        case 'previous_not_stopped': {
+            const wait = msg(reason === 'previous_not_stopped' ? 'engine.unavailable.wait.exit' : facts.answer === 'unanswered' ? 'engine.unavailable.wait.respond' : 'engine.unavailable.wait.healthy');
             return facts.pid !== undefined ? msg('engine.unavailable.fix.waitPid', { wait, again, pid: facts.pid }) : msg('engine.unavailable.fix.wait', { wait, again });
         }
         case 'address_refused':
@@ -427,8 +430,7 @@ export function engineUnavailableLine(facts, lane, lang) {
         const sigRaw = own(facts, 'engineSignal');
         const pidRaw = own(facts, 'pid');
         const pid = typeof pidRaw === 'number' && Number.isInteger(pidRaw) && pidRaw > 0 ? pidRaw : undefined;
-        const answerRaw = own(facts, 'answer');
-        const answer = answerRaw === 'silent' || answerRaw === 'answered' || answerRaw === 'drain-stuck' ? answerRaw : undefined;
+        const answer = healthProbeVerdictOf(own(facts, 'answer'))?.kind;
         const refusal = refusalView(own(facts, 'refusal'));
         const form = formOf(own(facts, 'form'));
         const reason = refusal.reason ?? hostReason;
@@ -462,14 +464,16 @@ export function engineUnavailableLine(facts, lane, lang) {
         const head = reason === undefined
             ? msg('engine.unavailable.head.unknown')
             : reason === 'not_answering'
-                ? msg(answer === 'silent' ? 'engine.unavailable.head.notAnswering' : answer === 'drain-stuck' ? 'engine.unavailable.head.drainStuck' : 'engine.unavailable.head.noHealthyAnswer')
-                : reason === 'address_refused'
-                    ? msg('engine.unavailable.head.addressRefused')
-                    : reason === 'version_refused'
-                        ? msg('engine.unavailable.head.versionRefused')
-                        : reason === 'not_running' || (reason === 'model_setup' && refusal.reason === undefined)
-                            ? msg('engine.unavailable.head.notRunning')
-                            : msg('engine.unavailable.head.refused');
+                ? msg(answer === 'unanswered' ? 'engine.unavailable.head.notAnswering' : 'engine.unavailable.head.noHealthyAnswer')
+                : reason === 'previous_not_stopped'
+                    ? msg('engine.unavailable.head.drainStuck')
+                    : reason === 'address_refused'
+                        ? msg('engine.unavailable.head.addressRefused')
+                        : reason === 'version_refused'
+                            ? msg('engine.unavailable.head.versionRefused')
+                            : reason === 'not_running' || (reason === 'model_setup' && refusal.reason === undefined)
+                                ? msg('engine.unavailable.head.notRunning')
+                                : msg('engine.unavailable.head.refused');
         let ref;
         if (reason === 'address_refused' || reason === 'version_refused') {
             ref = detail !== undefined ? msg('engine.unavailable.lineRefusedUse', { tag, head, detail }) : msg('engine.unavailable.lineRefusedUseNoDetail', { tag, head });

package/dist/engineUrl.js

@@ -1,4 +1,5 @@
 import { isLoopbackWireUrl } from './engineWireSdk.js';
+import { SETTINGS_HTTP_URL_FLAWS, SETTINGS_STARTS_WITH_HTTP_SCHEME } from './generated/settingsSchemaFns.js';
 const SLASH = 47;
 function refusedBase(reason) {
     return Object.freeze({ ok: false, reason });
@@ -18,7 +19,7 @@ export function normalizeEngineBaseUrl(raw) {
     const trimmed = raw.trim();
     if (trimmed.length === 0)
         return refusedBase('empty');
-    if (!/^https?:\/\//i.test(trimmed))
+    if (!SETTINGS_STARTS_WITH_HTTP_SCHEME(trimmed))
         return refusedBase('scheme');
     let parsed;
     try {
@@ -29,7 +30,8 @@ export function normalizeEngineBaseUrl(raw) {
     }
     if (parsed.username !== '' || parsed.password !== '')
         return refusedBase('userinfo');
-    if (trimmed.includes('?') || trimmed.includes('#'))
+    const parts = SETTINGS_HTTP_URL_FLAWS(trimmed, ['query', 'fragment']);
+    if (parts.includes('query') || parts.includes('fragment'))
         return refusedBase('query_or_fragment');
     return Object.freeze({ ok: true, url: withoutTrailingSlashes(trimmed) });
 }

package/dist/gateFailureCodes.js

@@ -1,8 +1,8 @@
-import { DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, isRefusedParkCode } from './engineErrorCodes.js';
+import { CORRUPT_ROW_ERROR_CODE, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, isRefusedParkCode } from './engineErrorCodes.js';
 import { RESUME_REFUSAL_CODES } from './resumeRefusalCopy.js';
 export function isGateStandingErrorCode(code, retriable) {
     return (code === RESUME_POLICY_FOLD_CODE ||
-        code === 'corrupt' ||
+        code === CORRUPT_ROW_ERROR_CODE ||
         (isRefusedParkCode(code) && retriable === true) ||
         (typeof code === 'string' && RESUME_REOPEN_CODES.includes(code) && retriable === true) ||
         code === DECIDE_WORKFLOW_PARKS_UNREADABLE ||

package/dist/generated/sdkFactTables.d.ts

@@ -10,4 +10,5 @@ export declare const SDK_PERMISSION_MODE_PERSIST_MISSES: readonly ["claim_releas
 export declare const SDK_DECIDE_BINDING_KEYS: readonly ["boundCallId", "boundInputHash"];
 export declare const SDK_APPROVAL_QUEUE_KINDS: readonly ["checkpoint", "peer_inbound"];
 export declare const SDK_SESSION_MEMORY_UNOBSERVED_REASONS: readonly ["no_settled_run", "run_result_missing", "run_result_unobserved", "memory_not_mounted", "no_leaf"];
+export declare const SDK_NON_RETRYABLE_CODES: readonly ["corrupt_session", "config.tool_name_too_long", "config.tool_contract_too_long", "config.tool_roster_bound", "config.tool_schema_bound", "state.scenario_assignment_unknown", "corrupt", "internal.memory_control_plane_corrupt", "approvals.read_corrupt", "workflow.journal_incompatible", "internal.org_delivery_quota_unreadable"];
 export declare const SDK_STREAM_ENDED_REASONS: readonly ["empty_legs", "consecutive_failures"];

package/dist/generated/sdkFactTables.js

@@ -64,6 +64,19 @@ export const SDK_SESSION_MEMORY_UNOBSERVED_REASONS = Object.freeze([
     "memory_not_mounted",
     "no_leaf",
 ]);
+export const SDK_NON_RETRYABLE_CODES = Object.freeze([
+    "corrupt_session",
+    "config.tool_name_too_long",
+    "config.tool_contract_too_long",
+    "config.tool_roster_bound",
+    "config.tool_schema_bound",
+    "state.scenario_assignment_unknown",
+    "corrupt",
+    "internal.memory_control_plane_corrupt",
+    "approvals.read_corrupt",
+    "workflow.journal_incompatible",
+    "internal.org_delivery_quota_unreadable",
+]);
 export const SDK_STREAM_ENDED_REASONS = Object.freeze([
     "empty_legs",
     "consecutive_failures",

package/dist/generated/settingsSchemaFns.d.ts

@@ -111,3 +111,4 @@ export declare const SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL: (models: {
     };
 };
 export declare const SETTINGS_DEFAULT_ROLE_TIER_LADDER: readonly ["pro", "flash", "lite"];
+export declare const SETTINGS_HTTP_URL_FLAWS: (raw: string, forbid: readonly ("userinfo" | "query" | "fragment")[]) => readonly ("not-http-url" | "userinfo" | "query" | "fragment")[];

package/dist/generated/settingsSchemaFns.js

@@ -15,6 +15,7 @@ import { SETTINGS_LAYER_SOURCES_CLOSURE } from './settingsSchemaSettingsSources.
 import { SETTINGS_ACTIVE_TIERS_CLOSURE } from './settingsSchemaActiveTiers.js';
 import { SETTINGS_TIER_WORDS_CLOSURE } from './settingsSchemaTierWords.js';
 import { SETTINGS_DEFAULT_MODEL_CLOSURE } from './settingsSchemaDefaultModel.js';
+import { SETTINGS_URL_SHAPE_CLOSURE } from './settingsSchemaUrlShape.js';
 export const SETTINGS_AT_MENTION_MODES = Object.freeze([
     "all",
     "none",
@@ -198,3 +199,5 @@ export const SETTINGS_TIER_LADDER_FROM = SETTINGS_TIER_WORDS.tierLadderFrom;
 const SETTINGS_DEFAULT_MODEL = SETTINGS_DEFAULT_MODEL_CLOSURE(SETTINGS_RESOLVE_ACTIVE_TIERS, SETTINGS_TIER_LADDER_FROM);
 export const SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL = SETTINGS_DEFAULT_MODEL.resolveCatalogDefaultModel;
 export const SETTINGS_DEFAULT_ROLE_TIER_LADDER = SETTINGS_DEFAULT_MODEL.DEFAULT_ROLE_TIER_LADDER;
+const SETTINGS_URL_SHAPE = SETTINGS_URL_SHAPE_CLOSURE(SETTINGS_IS_HIERARCHICAL_URL);
+export const SETTINGS_HTTP_URL_FLAWS = SETTINGS_URL_SHAPE.httpUrlFlaws;