@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/userInvokedSkillsCapability.js

@@ -1,6 +1,7 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
-import { ownDataField } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectUserInvokedSkillsCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -20,9 +21,6 @@ const reader = createEngineCapReader({
     name: 'userInvokedSkills',
     project: projectUserInvokedSkillsCapability,
 });
-export function noteEngineCapsForUserInvokedSkills(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedUserInvokedSkills(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -33,17 +31,40 @@ export function userInvokedSkillsAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function userInvokedSkillsDoctorDetail(reading) {
+export function userInvokedSkillsDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.userInvokedSkills');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('user-invoked skills');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         case 'unobserved':
-            return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); 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)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'userInvokedSkills' }), lang);
         case 'not_reported':
-            return 'user-invoked skills not reported by this engine — the engine predates it, so naming skills on a request is refused (do not send the key)';
+            return renderMessage(msg('notice.capability.userInvokedSkills.notReported'), lang);
         case 'absent':
-            return 'user-invoked skills off on this deployment — naming skills on a request is not accepted';
+            return renderMessage(msg('notice.capability.userInvokedSkills.absent'), lang);
         case 'present':
-            return 'user-invoked skills on — skills the user names on a request take effect when the run starts';
+            return renderMessage(msg('notice.capability.userInvokedSkills.present'), lang);
+    }
+}
+export function userInvokedSkillsDeclaration(names, reading) {
+    let named = false;
+    try {
+        named = Array.isArray(names) && names.length > 0;
+    }
+    catch {
+        named = false;
+    }
+    if (!named)
+        return { field: {} };
+    let kind;
+    try {
+        kind = reading !== null && typeof reading === 'object' ? readOwnDataValue(reading, 'kind') : undefined;
+    }
+    catch {
+        kind = undefined;
     }
+    if (kind === 'present')
+        return { field: { userInvokedSkills: names } };
+    const cause = kind === 'absent' || kind === 'not_reported' || kind === 'unobserved' ? kind : 'unreadable';
+    return { field: {}, withheld: { cause } };
 }

package/dist/webSearchBackendCapability.d.ts

@@ -15,9 +15,5 @@ export type WebSearchBackendReading = {
     view: WebSearchBackendCapabilityView;
 };
 export declare function projectWebSearchBackendCapability(caps: unknown): WebSearchBackendReading | undefined;
-export declare function noteEngineCapsForWebSearchBackend(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedWebSearchBackend(baseUrl?: string | undefined): WebSearchBackendReading;
 export declare function webSearchBackendDoctorDetail(reading: WebSearchBackendReading): string;
-export declare function __resetWebSearchBackendReadingsForTests(): void;

package/dist/webSearchBackendCapability.js

@@ -29,9 +29,6 @@ const reader = createEngineCapReader({
     name: 'webSearch.backend',
     project: projectWebSearchBackendCapability,
 });
-export function noteEngineCapsForWebSearchBackend(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedWebSearchBackend(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -56,6 +53,3 @@ export function webSearchBackendDoctorDetail(reading) {
                 '(per-request overrides are not echoed here)');
     }
 }
-export function __resetWebSearchBackendReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/wireErrorTriage.d.ts

@@ -21,6 +21,13 @@ export declare function classifyTurnWireError(err: unknown): TurnWireErrorVerdic
 export declare function isWireTransportError(err: unknown): boolean;
 export declare function isPreStreamDrainingReject(err: unknown): boolean;
 export declare function effectiveWireErrorCode(err: unknown): string | undefined;
+export type NotFoundFailure = {
+    readonly kind: 'not_found';
+    readonly code: string;
+} | {
+    readonly kind: 'unknown_404';
+};
+export declare function isNotFoundFailure(e: {} | null | undefined): NotFoundFailure | false;
 export declare function corruptStoredRowWhere(err: unknown): string | undefined;
 export declare function corruptStoredRowContent(where: string): string;
 export declare function isResumeAtRejection(err: unknown): boolean;

package/dist/wireErrorTriage.js

@@ -1,8 +1,8 @@
-import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, protocolErrorNameOf, readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, readThrownStatusSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
 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,16 +72,32 @@ export function isPreStreamDrainingReject(err) {
 export function effectiveWireErrorCode(err) {
     if (typeof err !== 'object' || err === null)
         return undefined;
-    let outerRaw;
+    const outerRaw = readThrownSlot(err, 'errorCode', 'data');
+    const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
+    return foldedWireErrorCode(err, outer);
+}
+export function isNotFoundFailure(e) {
     try {
-        outerRaw = err.errorCode;
+        if (e === null || e === undefined || (typeof e !== 'object' && typeof e !== 'function'))
+            return false;
+        const code = readThrownSlot(e, 'errorCode', 'data');
+        if (code === THROWN_SLOT_UNREADABLE)
+            return false;
+        if (typeof code === 'string') {
+            return code.startsWith(NOT_FOUND_CODE_PREFIX) ? Object.freeze({ kind: 'not_found', code }) : false;
+        }
+        const status = readThrownStatusSlot(e);
+        if (status === 404)
+            return Object.freeze({ kind: 'unknown_404' });
+        if (status === undefined && typeof e === 'object' && protocolErrorNameOf(e) === PROTOCOL_ERROR_NAME.NotFoundError)
+            return Object.freeze({ kind: 'unknown_404' });
+        return false;
     }
     catch {
-        outerRaw = undefined;
+        return false;
     }
-    const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
-    return foldedWireErrorCode(err, outer);
 }
+const NOT_FOUND_CODE_PREFIX = 'not_found.';
 function foldedWireErrorCode(err, outer) {
     if (outer !== RESUME_POLICY_FOLD_CODE)
         return outer;
@@ -93,7 +109,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 +166,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

@@ -1,3 +1,4 @@
+import { msg, renderMessage } from './i18n/translate.js';
 import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
 export function readThrownSlot(o, key, own = false) {
@@ -105,6 +106,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 +268,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 +290,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 +319,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 +351,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(renderMessage(msg('config.assembly.thrownDuringAssembly', { who })), { 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

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
@@ -77,14 +77,36 @@ 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;
 }
 export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
 export declare function autonomyLaneRefusalContent(): string;
+export interface UserAttachmentRefusalDetail {
+    readonly code: typeof USER_ATTACHMENT_INVALID_ERROR_CODE;
+    readonly retryable: false;
+}
+export declare function userAttachmentRefusalFromError(err: {} | null | undefined): UserAttachmentRefusalDetail | null;
+export declare function userAttachmentRefusalContent(): string;
+export interface UserInvokedSkillRefusalDetail {
+    readonly code: typeof USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE;
+    readonly retryable: false;
+}
+export declare function userInvokedSkillRefusalFromError(err: {} | null | undefined): UserInvokedSkillRefusalDetail | null;
+export declare function userInvokedSkillRefusalContent(): string;