@sema-agent/client-core 0.97.1 → 0.98.0

package/dist/wireErrorTriage.js

@@ -2,7 +2,7 @@ import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, r
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
-import { DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
+import { CORRUPT_ROW_ERROR_CODE, DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|\bterminated\b|\bother side closed\b/i;
 function readTurnErrorSlots(err) {
     if (err === null || err === undefined)
@@ -72,13 +72,7 @@ export function isPreStreamDrainingReject(err) {
 export function effectiveWireErrorCode(err) {
     if (typeof err !== 'object' || err === null)
         return undefined;
-    let outerRaw;
-    try {
-        outerRaw = err.errorCode;
-    }
-    catch {
-        outerRaw = undefined;
-    }
+    const outerRaw = readThrownSlot(err, 'errorCode', 'data');
     const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
     return foldedWireErrorCode(err, outer);
 }
@@ -93,7 +87,7 @@ export function corruptStoredRowWhere(err) {
     return typeof err === 'object' && err !== null ? storedRowWhereOf(err, code) : undefined;
 }
 function storedRowWhereOf(err, effectiveCode) {
-    if (effectiveCode !== 'corrupt')
+    if (effectiveCode !== CORRUPT_ROW_ERROR_CODE)
         return undefined;
     const where = readErrorString(err, 'where');
     return where !== undefined && where.trim().length > 0 ? where : undefined;
@@ -150,24 +144,11 @@ export function streamDrainingDecision(frame, attempt, opts) {
 export function scenarioDenyFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    const e = err;
-    let status;
-    try {
-        status = e.status;
-    }
-    catch {
-        return null;
-    }
+    const status = readThrownSlot(err, 'status', 'data');
     if (status !== 400 && status !== 409)
         return null;
     if (status === 409) {
-        let outer;
-        try {
-            outer = e.errorCode;
-        }
-        catch {
-            return null;
-        }
+        const outer = readThrownSlot(err, 'errorCode', 'data');
         if (outer !== RESUME_POLICY_FOLD_CODE)
             return null;
     }

package/dist/wireFailureShape.d.ts

@@ -4,9 +4,10 @@ interface WireFailureShape {
     retryAfterSec?: number;
     committed?: 'no' | 'unknown' | 'unreadable';
     bodyField?: string;
-    bodyName?: string;
     bodyVerdict?: string;
     bodyCurrentName?: string;
+    bodyEntry?: string;
+    bodyReason?: string;
     message: string;
 }
 export declare const THROWN_SLOT_UNREADABLE: unique symbol;
@@ -21,6 +22,40 @@ export type ThrownExtraReading = {
     readonly state: 'unreadable';
 };
 export declare function readThrownExtra(o: {} | null | undefined): ThrownExtraReading;
+export declare const PROTOCOL_ERROR_NAME: Readonly<{
+    readonly ApprovalBindingMismatchError: "ApprovalBindingMismatchError";
+    readonly ApprovalStaleError: "ApprovalStaleError";
+    readonly AskDecidedError: "AskDecidedError";
+    readonly ConflictError: "ConflictError";
+    readonly NotFoundError: "NotFoundError";
+    readonly ParkedResumeStartupError: "ParkedResumeStartupError";
+    readonly RateLimitedError: "RateLimitedError";
+    readonly SteeringAmbiguousTargetError: "SteeringAmbiguousTargetError";
+    readonly SteeringDuplicateInputIdError: "SteeringDuplicateInputIdError";
+    readonly SteeringError: "SteeringError";
+    readonly SteeringInvalidContentError: "SteeringInvalidContentError";
+    readonly SteeringLedgerUnavailableError: "SteeringLedgerUnavailableError";
+    readonly SteeringNotRunningError: "SteeringNotRunningError";
+    readonly SteeringQueueFullError: "SteeringQueueFullError";
+    readonly SteeringStillRunningError: "SteeringStillRunningError";
+    readonly UsageWindowExhaustedError: "UsageWindowExhaustedError";
+}>;
+export type ProtocolErrorName = (typeof PROTOCOL_ERROR_NAME)[keyof typeof PROTOCOL_ERROR_NAME];
+export declare function isSdkErrorInstance(o: object): boolean;
+export type ProtocolErrorNameReading = {
+    readonly state: 'named';
+    readonly name: ProtocolErrorName;
+} | {
+    readonly state: 'absent';
+} | {
+    readonly state: 'sdk-instance';
+} | {
+    readonly state: 'unreadable';
+};
+export declare function protocolErrorNameReading(e: object): ProtocolErrorNameReading;
+export declare function protocolErrorNameOf(e: object): ProtocolErrorName | undefined;
+export type ThrownStatusReading = number | undefined | typeof THROWN_SLOT_UNREADABLE;
+export declare function readThrownStatusSlot(o: object): ThrownStatusReading;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
 export declare function readErrorString(o: object, key: string): string | undefined;
@@ -28,10 +63,17 @@ export declare function readErrorStringList(o: object, key: string): readonly st
 export declare function readErrorStrictStringList(o: object, key: string): readonly string[] | undefined;
 export declare const WIRE_FAILURE_UNRENDERABLE_TEXT = "the call failed with an error this client could not render";
 export declare function wireFailureShapeOf(e: unknown): WireFailureShape;
-export declare function wireFailureTextsOf(e: unknown): {
-    reason: string;
-    log: string;
-};
+export interface WireFailureCore {
+    readonly status?: number;
+    readonly errorCode?: string;
+    readonly message: string;
+}
+export declare function wireFailureCoreOf(e: {} | null | undefined): WireFailureCore;
+export interface WireFailureTexts {
+    readonly reason: string;
+    readonly log: string;
+}
+export declare function wireFailureTextsOf(e: unknown): WireFailureTexts;
 export type BlockedByReading = {
     kind: 'named';
     code: string;
@@ -42,4 +84,19 @@ export type BlockedByReading = {
 };
 export declare function readBlockedBy(o: object): BlockedByReading;
 export declare function readRefusalField(o: object): string | undefined;
+export declare function isDisplayableWireCode(s: string): boolean;
+export declare const ASSEMBLY_REFUSAL_CAUSES: readonly ["ports_missing", "judge_unanswerable", "input_malformed", "agents_projection_failed", "agents_not_ready"];
+export interface AssemblyRefusal {
+    readonly code: 'assembly_refused';
+    readonly detail: {
+        readonly cause: (typeof ASSEMBLY_REFUSAL_CAUSES)[number];
+    };
+}
+export declare function assemblyRefusal(cause: AssemblyRefusal['detail']['cause']): AssemblyRefusal;
+export declare function withAssemblyRefusal<E extends Error>(err: E, cause: AssemblyRefusal['detail']['cause']): E;
+export declare function asAssemblyRefusal(thrown: {} | null | undefined, cause: AssemblyRefusal['detail']['cause'], who: string): {};
+export declare function assemblyRefusalOf(x: {} | null | undefined): {
+    readonly code: 'assembly_refused';
+    readonly cause: AssemblyRefusal['detail']['cause'] | 'unknown';
+} | undefined;
 export {};

package/dist/wireFailureShape.js

@@ -105,6 +105,57 @@ export function readThrownExtra(o) {
     }
     return { state: 'object', value: slot };
 }
+export const PROTOCOL_ERROR_NAME = Object.freeze({
+    ApprovalBindingMismatchError: 'ApprovalBindingMismatchError',
+    ApprovalStaleError: 'ApprovalStaleError',
+    AskDecidedError: 'AskDecidedError',
+    ConflictError: 'ConflictError',
+    NotFoundError: 'NotFoundError',
+    ParkedResumeStartupError: 'ParkedResumeStartupError',
+    RateLimitedError: 'RateLimitedError',
+    SteeringAmbiguousTargetError: 'SteeringAmbiguousTargetError',
+    SteeringDuplicateInputIdError: 'SteeringDuplicateInputIdError',
+    SteeringError: 'SteeringError',
+    SteeringInvalidContentError: 'SteeringInvalidContentError',
+    SteeringLedgerUnavailableError: 'SteeringLedgerUnavailableError',
+    SteeringNotRunningError: 'SteeringNotRunningError',
+    SteeringQueueFullError: 'SteeringQueueFullError',
+    SteeringStillRunningError: 'SteeringStillRunningError',
+    UsageWindowExhaustedError: 'UsageWindowExhaustedError',
+});
+const PROTOCOL_ERROR_NAMES = new Set(Object.values(PROTOCOL_ERROR_NAME));
+export function isSdkErrorInstance(o) {
+    try {
+        return extraSlotOf(o).kind === 'sdk-class';
+    }
+    catch {
+        return false;
+    }
+}
+export function protocolErrorNameReading(e) {
+    if (typeof e !== 'object' || e === null)
+        return { state: 'absent' };
+    try {
+        if (isSdkErrorInstance(e))
+            return { state: 'sdk-instance' };
+        const name = ownDataField(e, 'name');
+        return typeof name === 'string' && PROTOCOL_ERROR_NAMES.has(name) ? { state: 'named', name: name } : { state: 'absent' };
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+}
+export function protocolErrorNameOf(e) {
+    const r = protocolErrorNameReading(e);
+    return r.state === 'named' ? r.name : undefined;
+}
+export function readThrownStatusSlot(o) {
+    const st = readThrownSlot(o, 'status', 'data');
+    const raw = st !== THROWN_SLOT_UNREADABLE && (st === undefined || st === null) ? readThrownSlot(o, 'statusCode', 'data') : st;
+    if (raw === undefined)
+        return undefined;
+    return typeof raw === 'number' ? raw : THROWN_SLOT_UNREADABLE;
+}
 function readErrorSlot(obj, key, accept) {
     try {
         const topRaw = readThrownSlot(obj, key, 'data');
@@ -216,9 +267,10 @@ export function wireFailureShapeOf(e) {
         }
     };
     const bodyField = ownString('field');
-    const bodyName = ownString('name');
     const bodyVerdict = ownString('verdict');
     const bodyCurrentName = ownString('currentName');
+    const bodyEntry = ownString('entry');
+    const bodyReason = ownString('reason');
     const ownMessage = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : undefined;
     const message = userFacingReasonOf(e, ownMessage);
     const sec = typeof retryAfterMs === 'number' && Number.isFinite(retryAfterMs) && retryAfterMs >= 0
@@ -237,12 +289,21 @@ export function wireFailureShapeOf(e) {
         ...(sec !== undefined ? { retryAfterSec: sec } : {}),
         ...(committed !== undefined ? { committed } : {}),
         ...(bodyField !== undefined ? { bodyField } : {}),
-        ...(bodyName !== undefined ? { bodyName } : {}),
         ...(bodyVerdict !== undefined ? { bodyVerdict } : {}),
         ...(bodyCurrentName !== undefined ? { bodyCurrentName } : {}),
+        ...(bodyEntry !== undefined ? { bodyEntry } : {}),
+        ...(bodyReason !== undefined ? { bodyReason } : {}),
         message,
     };
 }
+export function wireFailureCoreOf(e) {
+    const shape = wireFailureShapeOf(e);
+    return {
+        ...(shape.status !== undefined ? { status: shape.status } : {}),
+        ...(shape.errorCode !== undefined ? { errorCode: shape.errorCode } : {}),
+        message: shape.message,
+    };
+}
 export function wireFailureTextsOf(e) {
     const { message } = wireFailureShapeOf(e);
     let log;
@@ -257,14 +318,18 @@ export function wireFailureTextsOf(e) {
 export function readBlockedBy(o) {
     const judge = (v) => (typeof v === 'string' && v.length > 0 ? { kind: 'named', code: v } : { kind: 'unreadable' });
     try {
-        const top = o['blockedBy'];
+        const top = readThrownSlot(o, 'blockedBy', 'data');
+        if (top === THROWN_SLOT_UNREADABLE)
+            return { kind: 'unreadable' };
         if (top !== undefined)
             return judge(top);
         const reading = readThrownExtra(o);
         if (reading.state === 'unreadable')
             return { kind: 'unreadable' };
-        if (reading.state === 'object' && Object.hasOwn(reading.value, 'blockedBy')) {
-            return judge(reading.value['blockedBy']);
+        if (reading.state === 'object') {
+            const d = Object.getOwnPropertyDescriptor(reading.value, 'blockedBy');
+            if (d !== undefined)
+                return Object.hasOwn(d, 'value') ? judge(d.value) : { kind: 'unreadable' };
         }
         return { kind: 'absent' };
     }
@@ -285,3 +350,38 @@ export function readRefusalField(o) {
     }
     return str(o);
 }
+const DISPLAYABLE_WIRE_CODE = /^[A-Za-z0-9._:-]{1,64}$/;
+export function isDisplayableWireCode(s) {
+    return DISPLAYABLE_WIRE_CODE.test(s);
+}
+export const ASSEMBLY_REFUSAL_CAUSES = Object.freeze([
+    'ports_missing',
+    'judge_unanswerable',
+    'input_malformed',
+    'agents_projection_failed',
+    'agents_not_ready',
+]);
+const CODE = 'assembly_refused';
+export function assemblyRefusal(cause) {
+    return Object.freeze({ code: CODE, detail: Object.freeze({ cause }) });
+}
+export function withAssemblyRefusal(err, cause) {
+    Object.defineProperty(err, 'code', { value: CODE, writable: true, enumerable: true, configurable: true });
+    Object.defineProperty(err, 'detail', { value: Object.freeze({ cause }), writable: true, enumerable: true, configurable: true });
+    return err;
+}
+export function asAssemblyRefusal(thrown, cause, who) {
+    if (assemblyRefusalOf(thrown) !== undefined)
+        return thrown;
+    return withAssemblyRefusal(new Error(`${who}: 装配时出错,拒绝装配(原抛出物见 cause)。`, { cause: thrown }), cause);
+}
+export function assemblyRefusalOf(x) {
+    if (x === null || x === undefined)
+        return undefined;
+    if (readThrownSlot(x, 'code', 'data') !== CODE)
+        return undefined;
+    const detail = readThrownSlot(x, 'detail', 'data');
+    const cause = typeof detail === 'object' && detail !== null ? readThrownSlot(detail, 'cause', 'data') : undefined;
+    const known = ASSEMBLY_REFUSAL_CAUSES.includes(cause) ? cause : 'unknown';
+    return Object.freeze({ code: CODE, cause: known });
+}

package/dist/wireRefusalCopy.d.ts

@@ -77,11 +77,21 @@ export interface HostPostureRefusalDetail {
 }
 export declare function hostPostureRefusalFromError(err: unknown, sentRequest?: TaskRequestLike): HostPostureRefusalDetail | null;
 export declare function hostPostureRefusalContent(detail: Pick<HostPostureRefusalDetail, 'askedWholeEnvironment' | 'askedOpenWriteFace'>): string;
-export interface HookMatcherRefusal {
+export type HookMatcherRefusal = {
+    readonly reason: 'alias_without_canonical';
     readonly event: string;
     readonly alias: string;
     readonly canonical: string;
-}
+} | {
+    readonly reason: 'invalid_regex';
+    readonly event: string;
+    readonly groupIndex: number;
+} | {
+    readonly reason: 'over_budget';
+    readonly event: string;
+    readonly groupIndex: number;
+    readonly budgetMs?: number;
+};
 export declare function hookMatcherRefusalFromError(err: unknown): HookMatcherRefusal | undefined;
 export interface AutonomyLaneRefusalDetail {
     readonly code: typeof REQUEST_AUTONOMY_LANE_REFUSED;

package/dist/wireRefusalCopy.js

@@ -1,36 +1,24 @@
-import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField } from './wireFailureShape.js';
-import { readOwnNonEmptyString } from './ownKey.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
 import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 export const CONFLICT_APPROVAL_SETTLED = 'conflict.approval_settled';
 export const CONFLICT_RUN_NOT_RUNNING = 'conflict.run_not_running';
-function readStringField(o, key) {
-    const v = o[key];
+function ownNonEmptyStringSlot(o, key) {
+    const v = readThrownSlot(o, key, 'data');
     return typeof v === 'string' && v !== '' ? v : undefined;
 }
 export function cancelConflictFromError(err) {
-    let o;
-    try {
-        if (err === null || typeof err !== 'object')
-            return null;
-        o = err;
-        const rawStatus = o.status ?? o.statusCode;
-        const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
-        if (!is409)
-            return null;
-    }
-    catch {
+    if (err === null || typeof err !== 'object')
         return null;
-    }
-    let code;
-    try {
-        code = readStringField(o, 'errorCode');
-    }
-    catch {
-        code = undefined;
-    }
+    const rawStatus = readThrownStatusSlot(err);
+    if (rawStatus === THROWN_SLOT_UNREADABLE)
+        return null;
+    if (!(rawStatus === 409 || (rawStatus === undefined && protocolErrorNameOf(err) === PROTOCOL_ERROR_NAME.ConflictError)))
+        return null;
+    const code = ownNonEmptyStringSlot(err, 'errorCode');
     if (code === CONFLICT_APPROVAL_SETTLED)
         return { kind: 'approval_settled', code };
     if (code === CONFLICT_RUN_NOT_RUNNING)
@@ -58,17 +46,20 @@ export function usageWindowExhaustedFromError(err) {
         if (err === null || typeof err !== 'object')
             return null;
         const o = err;
-        if (o.errorCode !== USAGE_WINDOW_EXHAUSTED)
+        if (readThrownSlot(o, 'errorCode', 'data') !== USAGE_WINDOW_EXHAUSTED)
+            return null;
+        const rawStatus = readThrownStatusSlot(o);
+        if (rawStatus === THROWN_SLOT_UNREADABLE)
             return null;
-        const rawStatus = o.status ?? o.statusCode;
-        const is429 = rawStatus === 429 || (rawStatus === undefined && (o.name === 'UsageWindowExhaustedError' || o.name === 'RateLimitedError'));
+        const protocolName = rawStatus === undefined ? protocolErrorNameOf(o) : undefined;
+        const is429 = rawStatus === 429 || (rawStatus === undefined && (protocolName === PROTOCOL_ERROR_NAME.UsageWindowExhaustedError || protocolName === PROTOCOL_ERROR_NAME.RateLimitedError));
         if (!is429)
             return null;
         const rawSec = readErrorNumber(o, 'retryAfterSec');
         const sec = nonNegativeFinite(rawSec)
             ? Math.ceil(rawSec)
             : (() => {
-                const rawMs = o.retryAfterMs;
+                const rawMs = readThrownSlot(o, 'retryAfterMs', 'data');
                 return nonNegativeFinite(rawMs) ? Math.ceil(rawMs / 1000) : undefined;
             })();
         return { code: USAGE_WINDOW_EXHAUSTED, ...(sec !== undefined ? { retryAfterSec: sec } : {}) };
@@ -98,13 +89,7 @@ const positiveFinite = (v) => typeof v === 'number' && Number.isFinite(v) && v >
 export function fleetLeaseUnavailableFromError(err) {
     if (err === null || typeof err !== 'object')
         return null;
-    let code;
-    try {
-        code = err.errorCode;
-    }
-    catch {
-        return null;
-    }
+    const code = readThrownSlot(err, 'errorCode', 'data');
     if (code !== FLEET_LEASE_UNAVAILABLE)
         return null;
     const reason = readErrorString(err, 'reason');
@@ -190,11 +175,11 @@ export function denyAttributionRefusalFromError(err, sentAttributionKey) {
         if (err === null || typeof err !== 'object')
             return null;
         const o = err;
-        const rawStatus = o.status ?? o.statusCode;
+        const rawStatus = readThrownStatusSlot(o);
         const status = typeof rawStatus === 'number' && Number.isFinite(rawStatus) ? rawStatus : undefined;
         if (status === undefined)
             return null;
-        const code = readStringField(o, 'errorCode');
+        const code = ownNonEmptyStringSlot(o, 'errorCode');
         if (code === undefined)
             return null;
         if (status === 400 && (code === SETTLED_BY_NOT_IN_PROOF || code === DECIDED_BY_NOT_IN_PROOF))
@@ -245,12 +230,12 @@ export function sessionDeleteConflictFromError(err) {
     try {
         if (err === null || typeof err !== 'object')
             return null;
-        const o = err;
-        const rawStatus = o.status ?? o.statusCode;
-        const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
-        if (!is409)
+        const rawStatus = readThrownStatusSlot(err);
+        if (rawStatus === THROWN_SLOT_UNREADABLE)
             return null;
-        const code = readStringField(o, 'errorCode');
+        if (!(rawStatus === 409 || (rawStatus === undefined && protocolErrorNameOf(err) === PROTOCOL_ERROR_NAME.ConflictError)))
+            return null;
+        const code = ownNonEmptyStringSlot(err, 'errorCode');
         if (code === CONFLICT_SESSION_CHILDREN_ALIVE) {
             const remaining = readErrorStringList(err, 'remaining')?.filter((id) => id.length > 0);
             return { kind: 'children_alive', code, ...(remaining !== undefined && remaining.length > 0 ? { remaining: Object.freeze(remaining) } : {}) };
@@ -391,13 +376,7 @@ export function toolDeclarationRefusalFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
             return null;
-        let code;
-        try {
-            code = err.errorCode;
-        }
-        catch {
-            return null;
-        }
+        const code = readThrownSlot(err, 'errorCode', 'data');
         if (typeof code !== 'string' || !CORE_TOOL_DECLARATION_CODES.includes(code))
             return null;
         return Object.freeze({ code });
@@ -600,11 +579,30 @@ export function hookMatcherRefusalFromError(err) {
         if (detail === undefined)
             return undefined;
         const event = readOwnNonEmptyString(detail, 'event');
-        const alias = readOwnNonEmptyString(detail, 'alias');
-        const canonical = readOwnNonEmptyString(detail, 'canonical');
-        if (event === undefined || alias === undefined || canonical === undefined)
+        if (event === undefined)
+            return undefined;
+        const reasonRaw = readOwnDataValue(detail, 'reason');
+        if (reasonRaw === undefined || reasonRaw === 'dead_alias') {
+            const alias = readOwnNonEmptyString(detail, 'alias');
+            const canonical = readOwnNonEmptyString(detail, 'canonical');
+            if (alias === undefined || canonical === undefined)
+                return undefined;
+            return Object.freeze({ reason: 'alias_without_canonical', event, alias, canonical });
+        }
+        if (reasonRaw !== 'invalid_regex' && reasonRaw !== 'over_budget')
+            return undefined;
+        const groupIndex = readOwnDataValue(detail, 'groupIndex');
+        if (typeof groupIndex !== 'number' || !Number.isInteger(groupIndex) || groupIndex < 0)
             return undefined;
-        return Object.freeze({ event, alias, canonical });
+        if (reasonRaw === 'invalid_regex')
+            return Object.freeze({ reason: 'invalid_regex', event, groupIndex });
+        const budget = readOwnDataValue(detail, 'budgetMs');
+        return Object.freeze({
+            reason: 'over_budget',
+            event,
+            groupIndex,
+            ...(typeof budget === 'number' && Number.isFinite(budget) && budget > 0 ? { budgetMs: budget } : {}),
+        });
     }
     catch {
         return undefined;

package/dist/workflowsJournalCapability.d.ts

@@ -10,10 +10,6 @@ export type WorkflowsJournalReading = {
     kind: 'present';
 };
 export declare function projectWorkflowsJournalCapability(caps: unknown): WorkflowsJournalReading | undefined;
-export declare function noteEngineCapsForWorkflowsJournal(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedWorkflowsJournal(baseUrl?: string | undefined): WorkflowsJournalReading;
 export declare function workflowsJournalAvailable(reading: WorkflowsJournalReading): 'yes' | 'no' | 'unknown';
 export declare function workflowsJournalDoctorDetail(reading: WorkflowsJournalReading): string;
-export declare function __resetWorkflowsJournalReadingsForTests(): void;

package/dist/workflowsJournalCapability.js

@@ -20,9 +20,6 @@ const reader = createEngineCapReader({
     name: 'workflowsJournal',
     project: projectWorkflowsJournalCapability,
 });
-export function noteEngineCapsForWorkflowsJournal(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedWorkflowsJournal(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -47,6 +44,3 @@ export function workflowsJournalDoctorDetail(reading) {
             return 'workflow journal on — a workflow’s execution journal can be read';
     }
 }
-export function __resetWorkflowsJournalReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/writeProtectionCapability.d.ts

@@ -24,10 +24,6 @@ export interface WriteProtectionPostureView {
     droppedDefaultRows?: readonly string[];
 }
 export declare function projectWriteProtectionPosture(wiring: unknown): WriteProtectionPostureView | undefined;
-export declare function noteEngineCapsForWriteProtection(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedWriteProtection(baseUrl?: string | undefined): WriteProtectionReading;
 export declare function writeProtectionDoctorDetail(reading: WriteProtectionReading): string;
 export declare function writeProtectionPostureDetail(posture: WriteProtectionPostureView): string;
-export declare function __resetWriteProtectionReadingsForTests(): void;

package/dist/writeProtectionCapability.js

@@ -66,9 +66,6 @@ const reader = createEngineCapReader({
     name: 'writeProtection',
     project: projectWriteProtectionCapability,
 });
-export function noteEngineCapsForWriteProtection(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedWriteProtection(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -113,6 +110,3 @@ export function writeProtectionPostureDetail(posture) {
         : '';
     return `source ${source} · ${String(posture.rows.length)} ${posture.rows.length === 1 ? 'name' : 'names'}: ${shown}${more}${dropped}`;
 }
-export function __resetWriteProtectionReadingsForTests() {
-    reader.__resetForTests();
-}