@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/controlRouter.js

@@ -1,4 +1,5 @@
 import { cancelConflictContent, cancelConflictFromError } from './wireRefusalCopy.js';
+import { STEERING_NOT_RUNNING } from './engineErrorCodes.js';
 import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { steerPriorityMode } from './steerPriorityCapability.js';
 import { preemptReadingOfAck, preemptReadingOfError } from './preemptWire.js';
@@ -166,7 +167,7 @@ export function errCodes(e) {
     return { code, name, status };
 }
 const STEERING_CODE_TO_SAFETY = new Map([
-    ['steering.not_running', 'not_running'],
+    [STEERING_NOT_RUNNING, 'not_running'],
     ['steering.invalid_content', 'invalid_content'],
     ['steering.queue_full', 'queue_full'],
     ['steering.duplicate_input_id', 'duplicate_input_id'],

package/dist/coreValuePorts.d.ts

@@ -154,6 +154,40 @@ export interface CoreValuePorts {
     runParkedOf(run: WorkflowRunParkedInputView): boolean;
     parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[];
     modelFaceResolvable(face: object, options?: ModelFaceOptionsView): ModelFaceVerdictView;
+    accountRowOfResult(result: {
+        readonly stats: AccountRowStatsView;
+    }): AccountRowView;
+    foldAccount(rows: Iterable<AccountRowView>): SessionAccountView;
+}
+export interface AccountRowView {
+    origin: 'run' | 'side_query';
+    tokens: number;
+    costMicroUsd?: number;
+    usageMissing?: true;
+}
+export interface AccountTotalView {
+    rows: number;
+    tokens: number;
+    costMicroUsd?: number;
+    usageMissing?: true;
+}
+export interface SessionAccountView extends AccountTotalView {
+    byOrigin: {
+        readonly run: AccountTotalView;
+        readonly side_query: AccountTotalView;
+    };
+}
+export interface AccountRowStatsView {
+    readonly tokens: number;
+    readonly costMicroUsd?: number;
+    readonly usageMissing?: true;
+    readonly nested?: AccountRowNestedStatsView;
+}
+export interface AccountRowNestedStatsView {
+    readonly tokens: number;
+    readonly turns: number;
+    readonly tasks: number;
+    readonly costMicroUsd?: number;
 }
 export interface WorkflowAgentStatusView {
     readonly status: string;
@@ -176,7 +210,7 @@ export type ModelFaceVerdictView = {
     readonly role: string;
     readonly code: string;
 };
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers", "IMPORTED_SETTINGS_LAYERS", "runParkedOf", "parkedAgentsOf", "modelFaceResolvable"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers", "IMPORTED_SETTINGS_LAYERS", "runParkedOf", "parkedAgentsOf", "modelFaceResolvable", "accountRowOfResult", "foldAccount"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -211,3 +245,7 @@ export declare function importedSettingsLayers(): CoreValuePorts['IMPORTED_SETTI
 export declare function runParkedOf(run: WorkflowRunParkedInputView): boolean | undefined;
 export declare function parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[] | undefined;
 export declare function modelFaceResolvable(face: object, options?: ModelFaceOptionsView): ModelFaceVerdictView | undefined;
+export declare function accountRowOfResult(result: {
+    readonly stats: AccountRowStatsView;
+}): AccountRowView | undefined;
+export declare function foldAccount(rows: Iterable<AccountRowView>): SessionAccountView | undefined;

package/dist/coreValuePorts.js

@@ -24,6 +24,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'runParkedOf',
     'parkedAgentsOf',
     'modelFaceResolvable',
+    'accountRowOfResult',
+    'foldAccount',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -142,3 +144,11 @@ export function modelFaceResolvable(face, options) {
     const fn = port('modelFaceResolvable');
     return fn === undefined ? undefined : fn(face, options);
 }
+export function accountRowOfResult(result) {
+    const fn = port('accountRowOfResult');
+    return fn === undefined ? undefined : fn(result);
+}
+export function foldAccount(rows) {
+    const fn = port('foldAccount');
+    return fn === undefined ? undefined : fn(rows);
+}

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/displayUntrusted.d.ts

@@ -51,6 +51,7 @@ export declare function capDisplay(text: string, max: number | undefined, mark:
 export declare function paintAndCap(text: string, face: DisplayFace, max?: number): string;
 export declare function credentialWashPasses(text: string, opts?: DisplayUntrustedOptions | null): Readonly<WashStats>;
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
+export declare function displayUntrustedCapped(text: string, max: number, opts?: DisplayUntrustedOptions): string;
 export declare function cleanUntrustedScalar(v: string | number | bigint | boolean | null | undefined): string;
 export declare function queryCarriesCredential(query: string): boolean;
 export declare function displayConfiguredUrl(url: string, opts?: DisplayUntrustedOptions): string;

package/dist/displayUntrusted.js

@@ -5236,6 +5236,12 @@ export function displayUntrusted(text, opts = {}) {
     const out = renderUntrusted(text, opts, null);
     return typeof out === 'string' ? out : out.tracked.text;
 }
+export function displayUntrustedCapped(text, max, opts = {}) {
+    const whole = displayUntrusted(text, opts);
+    if (typeof max !== 'number' || !Number.isFinite(max) || whole.length <= max)
+        return whole;
+    return `${displayUntrusted(text, { ...opts, max })}…`;
+}
 export function cleanUntrustedScalar(v) {
     return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false });
 }

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/engineHealthProbeVerdict.d.ts

@@ -0,0 +1,24 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import type { ProbeHealthResult } from '@sema-agent/sdk';
+export type HealthProbeUnansweredReason = 'timeout' | 'network';
+export type HealthProbeNotOkReason = 'http' | 'not_ok';
+export interface HealthProbeAnsweredNotOk {
+    readonly kind: 'answered_not_ok';
+    readonly reason: HealthProbeNotOkReason;
+    readonly http: number;
+    readonly status?: string;
+}
+export type HealthProbeVerdict = {
+    readonly kind: 'unanswered';
+    readonly reason: HealthProbeUnansweredReason;
+} | {
+    readonly kind: 'answered_ok';
+} | HealthProbeAnsweredNotOk;
+export interface TimedHealthAnswer {
+    readonly answer: HealthProbeAnsweredNotOk;
+    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

@@ -0,0 +1,123 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { slotReadOf } from './wireFailureShape.js';
+const UNANSWERED_REASONS = new Set(['timeout', 'network']);
+const NOT_OK_REASONS = new Set(['http', 'not_ok']);
+const REPORTED_STATUS_SHOWN_MAX = 64;
+function ownValue(o, key) {
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' ? r.value : undefined;
+}
+function isHttpCode(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 100 && v <= 599;
+}
+function shownStatusOf(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const shown = displayUntrusted(v, { max: REPORTED_STATUS_SHOWN_MAX });
+    return shown.trim() === '' ? undefined : shown;
+}
+function answeredNotOk(reason, http, status) {
+    return Object.freeze({ kind: 'answered_not_ok', reason, http, ...(status !== undefined ? { status } : {}) });
+}
+export function classifyHealthProbe(reading) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return undefined;
+        const alive = ownValue(reading, 'alive');
+        if (alive === true)
+            return Object.freeze({ kind: 'answered_ok' });
+        if (alive !== false)
+            return undefined;
+        const reason = ownValue(reading, 'reason');
+        if (typeof reason !== 'string')
+            return undefined;
+        if (UNANSWERED_REASONS.has(reason))
+            return Object.freeze({ kind: 'unanswered', reason: reason });
+        if (!NOT_OK_REASONS.has(reason))
+            return undefined;
+        const http = ownValue(reading, 'status');
+        if (!isHttpCode(http))
+            return undefined;
+        return answeredNotOk(reason, http, reason === 'not_ok' ? shownStatusOf(ownValue(reading, 'reportedStatus')) : undefined);
+    }
+    catch {
+        return undefined;
+    }
+}
+function answeredNotOkOf(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    if (ownValue(v, 'kind') !== 'answered_not_ok')
+        return undefined;
+    const reason = ownValue(v, 'reason');
+    const http = ownValue(v, 'http');
+    if (typeof reason !== 'string' || !NOT_OK_REASONS.has(reason) || !isHttpCode(http))
+        return undefined;
+    return answeredNotOk(reason, http, shownStatusOf(ownValue(v, 'status')));
+}
+export function healthProbeVerdictOf(v) {
+    try {
+        if (typeof v !== 'object' || v === null)
+            return undefined;
+        const kind = ownValue(v, 'kind');
+        if (kind === 'answered_ok')
+            return Object.freeze({ kind: 'answered_ok' });
+        if (kind === 'unanswered') {
+            const reason = ownValue(v, 'reason');
+            return typeof reason === 'string' && UNANSWERED_REASONS.has(reason) ? Object.freeze({ kind: 'unanswered', reason: reason }) : undefined;
+        }
+        return answeredNotOkOf(v);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function healthAnswerClause(verdict, lang) {
+    try {
+        const v = healthProbeVerdictOf(verdict);
+        if (v === undefined)
+            return undefined;
+        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;
+    }
+}
+function timedNotOkOf(s, start, bestAtMs) {
+    try {
+        if (typeof s !== 'object' || s === null)
+            return { kind: 'not_better' };
+        const atMs = ownValue(s, 'atMs');
+        if (typeof atMs !== 'number' || !Number.isFinite(atMs))
+            return { kind: 'not_better' };
+        if (start !== undefined && atMs < start)
+            return { kind: 'not_better' };
+        if (bestAtMs !== undefined && atMs <= bestAtMs)
+            return { kind: 'not_better' };
+        const answer = answeredNotOkOf(ownValue(s, 'answer'));
+        return answer === undefined ? { kind: 'not_better' } : { kind: 'better', entry: { atMs, answer } };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+export function latestSegmentHealthAnswer(segmentStartMs, ...seen) {
+    try {
+        const start = typeof segmentStartMs === 'number' && Number.isFinite(segmentStartMs) ? segmentStartMs : undefined;
+        let best;
+        for (const s of seen) {
+            const r = timedNotOkOf(s, start, best?.atMs);
+            if (r.kind === 'better')
+                best = r.entry;
+        }
+        return best?.answer;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/engineNoticeCodes.js

@@ -1,8 +1,8 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
-import { displayUntrusted } from './displayUntrusted.js';
+import { displayUntrusted, displayUntrustedCapped } from './displayUntrusted.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_APPROVAL_REMEDY_KINDS, CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DISCARDED_DELIVERY_PATHS, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
-import { msg, renderMessage } from './i18n/translate.js';
+import { msg, renderLanguageOf, renderMessage } from './i18n/translate.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
 import { inValueOf, slotReadOf } from './wireFailureShape.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
@@ -196,7 +196,6 @@ function readAskUnresolvableOf(notice) {
     };
 }
 export const DURABLE_MANDATE_SOURCES = CORE_DURABLE_MANDATE_SOURCES;
-const DURABLE_MANDATE_SOURCE_SET = new Set(DURABLE_MANDATE_SOURCES);
 export function readDurableGateUnavailable(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
@@ -213,7 +212,7 @@ export function readDurableGateUnavailable(notice) {
     const causeIn = o.cause;
     const sessionId = typeof sessionIdIn === 'string' && sessionIdIn.length > 0 ? sessionIdIn : undefined;
     const runId = typeof runIdIn === 'string' && runIdIn.length > 0 ? runIdIn : undefined;
-    const source = typeof sourceIn === 'string' && DURABLE_MANDATE_SOURCE_SET.has(sourceIn) ? sourceIn : undefined;
+    const source = typeof sourceIn === 'string' && sourceIn.length > 0 ? sourceIn : undefined;
     const cause = typeof causeIn === 'string' && causeIn.length > 0 ? causeIn : undefined;
     if (sessionId === undefined || runId === undefined || source === undefined || cause === undefined) {
         return undefined;
@@ -1417,15 +1416,14 @@ function shownName(v) {
 function shownText(v, max) {
     if (v === undefined)
         return undefined;
-    const whole = displayUntrusted(v);
-    const s = whole.length <= max ? whole : `${displayUntrusted(v, { max: max - 1 })}…`;
+    const s = displayUntrustedCapped(v, max);
     return s.length > 0 ? s : undefined;
 }
 function wordLookup(table, word) {
     return Object.hasOwn(table, word) ? table[word] : undefined;
 }
 function joinSentences(parts, lang) {
-    return parts.filter((p) => p !== undefined && p.length > 0).join(lang === 'zh' ? '' : ' ');
+    return parts.filter((p) => p !== undefined && p.length > 0).join(renderLanguageOf(lang) === 'zh' ? '' : ' ');
 }
 export function memorySessionPollutedSentence(facts, lang) {
     try {