@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/subagent/engineSubagentResume.js

@@ -1,7 +1,7 @@
 import { hostLog } from '../host.js';
 import { isNotFoundFailure, resumeRetryLaterFromError } from '../wireErrorTriage.js';
 import { readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
-import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
+import { RESUME_SESSION_NOT_FOUND, STEERING_NOT_RUNNING } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
@@ -63,7 +63,7 @@ export function classifySubagentResumeFailure(e) {
     }
     if (errorCode === 'steering.still_running')
         return { reason: 'still-running', detail: message };
-    if (errorCode === 'steering.not_running')
+    if (errorCode === STEERING_NOT_RUNNING)
         return { reason: 'not-resumable', detail: message };
     if (errorCode === 'steering.ambiguous_target')
         return { reason: 'ambiguous-target', detail: message };

package/dist/subagent/engineSubagentTail.js

@@ -4,7 +4,7 @@ import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected
 import { engineCapStateVia } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
-import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
+import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, subagentToolEndDenialParts, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { readFrameTrueMark } from '../ownKey.js';
 import { publishEngineInlineTaskModel } from '../engineInlineTaskStats.js';
@@ -143,6 +143,7 @@ export function tailEngineSubagent(taskId, opts) {
                         ...(out !== undefined ? { output: out } : {}),
                         ...(d.isError === true ? { isError: true } : {}),
                         ...(readFrameTrueMark(d, 'notExecuted') ? { notExecuted: true } : {}),
+                        ...subagentToolEndDenialParts(d),
                     });
                 }
                 else if (t === 'task_settled') {

package/dist/subagentContentStore.d.ts

@@ -1,3 +1,4 @@
+import { type CcToolDenialKind } from './gateVocabulary.js';
 export type SubagentContentItem = {
     kind: 'text';
     text: string;
@@ -12,6 +13,8 @@ export type SubagentContentItem = {
     output?: string;
     isError?: boolean;
     notExecuted?: true;
+    denialKind?: CcToolDenialKind;
+    refusalNoted?: true;
 } | {
     kind: 'echo';
     text: string;
@@ -33,7 +36,13 @@ export interface SubagentContentEvent {
     output?: string | undefined;
     isError?: boolean | undefined;
     notExecuted?: true | undefined;
+    denialKind?: CcToolDenialKind | undefined;
+    refusalNoted?: true | undefined;
 }
+export declare function subagentToolEndDenialParts(frame: object): {
+    denialKind?: CcToolDenialKind;
+    refusalNoted?: true;
+};
 export declare function coerceOutput(v: unknown): string | undefined;
 export declare function subagentContentEventOf(ev: {
     readonly type: string;
@@ -97,6 +106,8 @@ export type SubagentViewSlot = {
     output?: string;
     isError?: boolean;
     notExecuted?: true;
+    denialKind?: CcToolDenialKind;
+    refusalNoted?: true;
 };
 export declare function planSubagentViewSlots(taskId: string): SubagentViewSlot[];
 export declare function parentToolCallIdOf(taskId: string): string | undefined;

package/dist/subagentContentStore.js

@@ -1,7 +1,18 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
-import { readFrameTrueMark, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { guardedRead, readFrameTrueMark, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { toolEndOutputText } from './toolResultContent.js';
+import { ccToolDenialKindForToolEnd, gateOutcomeOf } from './gateOutcome.js';
+import { isCcToolDenialKind } from './gateVocabulary.js';
+import { refusalNotedOf } from './engineRowRef.js';
+export function subagentToolEndDenialParts(frame) {
+    const denialKind = guardedRead(() => ccToolDenialKindForToolEnd(frame));
+    const gate = guardedRead(() => gateOutcomeOf(frame));
+    return {
+        ...(denialKind !== undefined ? { denialKind } : {}),
+        ...(refusalNotedOf(denialKind, gate) ? { refusalNoted: true } : {}),
+    };
+}
 export function coerceOutput(v) {
     return toolEndOutputText(v);
 }
@@ -26,6 +37,7 @@ export function subagentContentEventOf(ev) {
         output: coerceOutput(sub.output),
         isError: sub.isError,
         notExecuted: readFrameTrueMark(sub, 'notExecuted') ? true : undefined,
+        ...(t === 'tool_end' ? subagentToolEndDenialParts(ev) : {}),
     };
 }
 const MAX_ITEMS_PER_TASK = 200;
@@ -633,16 +645,26 @@ export function publishSubagentContentEvent(ev) {
                 const outBefore = it.output;
                 const errBefore = it.isError;
                 const notExecBefore = it.notExecuted;
+                const denialBefore = it.denialKind;
+                const notedBefore = it.refusalNoted;
                 it.output = ev.output ?? '';
                 it.isError = ev.isError === true;
                 if (ev.notExecuted === true)
                     it.notExecuted = true;
                 else
                     delete it.notExecuted;
+                if (isCcToolDenialKind(ev.denialKind))
+                    it.denialKind = ev.denialKind;
+                else
+                    delete it.denialKind;
+                if (ev.refusalNoted === true)
+                    it.refusalNoted = true;
+                else
+                    delete it.refusalNoted;
                 const delta = itemBytesOf(it) - before;
                 s.itemBytes[at] = (s.itemBytes[at] ?? 0) + delta;
                 addBytes(s, delta);
-                stampPhase(s, it.id, 'end', ev.eventId, it.output !== outBefore || it.isError !== errBefore || it.notExecuted !== notExecBefore);
+                stampPhase(s, it.id, 'end', ev.eventId, it.output !== outBefore || it.isError !== errBefore || it.notExecuted !== notExecBefore || it.denialKind !== denialBefore || it.refusalNoted !== notedBefore);
                 break;
             }
             const synthId = id ?? `${ev.taskId}-tool-${s.items.length}`;
@@ -654,6 +676,8 @@ export function publishSubagentContentEvent(ev) {
                 output: ev.output ?? '',
                 isError: ev.isError === true,
                 ...(ev.notExecuted === true ? { notExecuted: true } : {}),
+                ...(isCcToolDenialKind(ev.denialKind) ? { denialKind: ev.denialKind } : {}),
+                ...(ev.refusalNoted === true ? { refusalNoted: true } : {}),
             });
             recordCut(s);
             stampPhase(s, synthId, 'end', ev.eventId, true);
@@ -698,6 +722,8 @@ export function planSubagentViewSlots(taskId) {
                 ...(it.output !== undefined ? { output: it.output } : {}),
                 ...(it.isError === true ? { isError: true } : {}),
                 ...(it.notExecuted === true ? { notExecuted: true } : {}),
+                ...(it.denialKind !== undefined ? { denialKind: it.denialKind } : {}),
+                ...(it.refusalNoted === true ? { refusalNoted: true } : {}),
             });
         }
         else if (it.kind === 'text') {

package/dist/toolResult.d.ts

@@ -109,6 +109,7 @@ export interface ToolResultRowFlags {
     readonly interruptedNeverStarted: boolean;
     readonly approvalWindowExpired: boolean;
     readonly denialLimitWindowExpired: boolean;
+    readonly refusalNoted: boolean;
 }
 export declare function toolResultRowFlagsOf(row: object | null | undefined): ToolResultRowFlags;
 export type ToolKillCause = NonNullable<ReturnType<typeof toolKillCauseAcrossEngineIdentity>> | 'memory_pressure';

package/dist/toolResult.js

@@ -8,6 +8,7 @@ import { guardedRead, ownDataField, ownSnapshotWhenTyped, readFrameTrueMark, rea
 import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
+import { SEMA_REFUSAL_NOTED_KEY } from './engineRowRef.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 const LEGACY_STRUCTURED_DETAIL_TYPE = 'task-output';
 export function structuredDetailType(structured) {
@@ -318,6 +319,7 @@ export function toolResultRowFlagsOf(row) {
         interruptedNeverStarted: readFrameTrueMark(row, '_sema_interrupted_never_started'),
         approvalWindowExpired: readFrameTrueMark(row, '_sema_approval_window_expired'),
         denialLimitWindowExpired: readFrameTrueMark(row, '_sema_denial_limit_window_expired'),
+        refusalNoted: readFrameTrueMark(row, SEMA_REFUSAL_NOTED_KEY),
     });
 }
 const TOOL_KILL_TEXT = {

package/dist/turnFailurePresentation.js

@@ -3,7 +3,8 @@ import { classifyTurnWireError, isPreStreamDrainingReject } from './wireErrorTri
 import { isSseIdleError, streamEndedReasonOf } from './sseIdleTriage.js';
 import { runNotFollowedOf } from './runFollow.js';
 import { isCodeClassifiedGateFailure } from './gateFailureCodes.js';
-import { CORRUPT_ROW_ERROR_CODE, CORRUPT_SESSION_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { DRAINING_ERROR_CODE } from './engineErrorCodes.js';
+import { SDK_NON_RETRYABLE_CODES } from './generated/sdkFactTables.js';
 import { admissionWallRefusalContent, admissionWallRefusalFromError, bodyShapeRefusalFromError, bodyShapeRefusalTouchesSettings, fleetLeaseUnavailableContent, fleetLeaseUnavailableFromError, hostPostureRefusalContent, hostPostureRefusalFromError, fieldLimitRefusalContent, fieldLimitRefusalFromError, toolDeclarationRefusalContent, toolDeclarationRefusalFromError, usageWindowExhaustedContent, usageWindowExhaustedFromError, quotaExhaustedContent, quotaExhaustedFromError, userAttachmentRefusalFromError, } from './wireRefusalCopy.js';
 import { THROWN_SLOT_UNREADABLE, readErrorNumber, readThrownSlot, wireFailureTextsOf } from './wireFailureShape.js';
 import { effectiveCodeOf, ownReadingSlot, provablyNotSent, triageReadingOf } from './engineWireFor.js';
@@ -68,14 +69,7 @@ function isIdleWatchdog(err) {
         return false;
     }
 }
-const DETERMINISTIC_SERVER_CODES = new Set([
-    CORRUPT_SESSION_ERROR_CODE,
-    CORRUPT_ROW_ERROR_CODE,
-    SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
-    MEMORY_CONTROL_PLANE_CORRUPT,
-    'approvals.read_corrupt',
-    'workflow.journal_incompatible',
-]);
+const DETERMINISTIC_SERVER_CODES = new Set(SDK_NON_RETRYABLE_CODES);
 const BROWSER_FETCH_FAILURE = /\bfailed to fetch\b|\bnetworkerror\b|\bnetwork error\b|\bload failed\b/i;
 function httpShapeOf(verdict, code) {
     const status = verdict.status;
@@ -90,7 +84,7 @@ function httpShapeOf(verdict, code) {
         return { category: 'rate_limited', offer: false };
     if (code === 'budget.precall' || code === 'budget.exceeded')
         return { category: 'billing', offer: false };
-    if (code === 'draining' || verdict.leaseUnavailable === true || isPreStreamDrainingReject(facts))
+    if (code === DRAINING_ERROR_CODE || verdict.leaseUnavailable === true || isPreStreamDrainingReject(facts))
         return { category: 'server_error', offer: true };
     if (status === 501 || (code !== undefined && code.startsWith('capability.')))
         return { category: 'capability_unavailable', offer: false };

package/dist/userAttachmentEnvelope.d.ts

@@ -1,6 +1,6 @@
 import { type DescriptorView } from './humanTurnRead.js';
 export type UserAttachmentSource = 'at-mention' | 'compact-restore';
-export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied' | 'approval-required' | 'server-not-connected' | 'resource-not-listed' | 'read-failed';
+export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied' | 'approval-required' | 'server-not-connected' | 'resource-not-listed' | 'read-failed' | 'tools-elsewhere' | 'tools-location-unconfirmed';
 export type UserAttachmentMcpResourcePart = {
     readonly kind: 'text';
     readonly text: string;
@@ -77,6 +77,7 @@ export type UserAttachmentDescriptor = {
     readonly truncated: boolean;
 };
 export declare function showAttachmentName(s: string): string;
+export declare function showAttachmentNameCc(s: string): string;
 export declare function mintEnvelopeOf(d: DescriptorView, imageDelivery: 'attached' | 'not-attached'): string;
 export declare function seatTextOf(d: DescriptorView): string | undefined;
 export declare function mintReferenceOf(d: DescriptorView): string;

package/dist/userAttachmentEnvelope.js

@@ -1,4 +1,5 @@
 import { readDescriptor } from './humanTurnRead.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const TILDE_CLASS_RUN = /[~\u02DC\u2053\u223C\u301C\uFF5E]+/g;
 function envelopeFence(text) {
     let longest = 0;
@@ -29,6 +30,13 @@ export function showAttachmentName(s) {
         return cp > 0xffff ? `\\u{${cp.toString(16)}}` : `\\u${hex4(cp)}`;
     });
 }
+const CC_CONTROL_UNITS = /[\p{Cc}\u2028\u2029]/gu;
+export function showAttachmentNameCc(s) {
+    return String(s ?? '')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replace(CC_CONTROL_UNITS, (c) => `&#${c.charCodeAt(0)};`);
+}
 const ESCAPE_NOTE = 'Some lines contain line-break control characters inside the line; they are shown as escape sequences (such as \\r or \\u2028), so those lines are not byte-for-byte the same as the file.';
 const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
 function firstLine(source, what, name) {
@@ -169,6 +177,8 @@ const NOT_INCLUDED_REASON = Object.freeze({
     'server-not-connected': 'the MCP server it comes from is not connected',
     'resource-not-listed': 'the MCP server does not list that resource',
     'read-failed': 'reading it from the MCP server failed',
+    'tools-elsewhere': renderMessage(msg('attachments.withheld.toolsElsewhere.model')),
+    'tools-location-unconfirmed': renderMessage(msg('attachments.withheld.toolsLocationUnconfirmed.model')),
 });
 function targetWhat(target) {
     return target === 'directory' ? 'a directory' : target === 'file' ? 'a file' : 'a file or directory';

package/dist/wireErrorTriage.js

@@ -2,6 +2,7 @@ import { PROTOCOL_ERROR_NAME, effectiveWireCodeReading, isSlotCarrier, protocolE
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
+import { isStreamEndedWithoutTerminalError } from './sseIdleTriage.js';
 import { answerReadingOf, captureAnswer, captureUnanswered, causeSlotReadOf, effectiveCodeOf, noteTriageReading, ownReadingSlot } from './engineWireFor.js';
 import { CORRUPT_ROW_ERROR_CODE, DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, 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;
@@ -105,7 +106,7 @@ export function classifyTurnWireError(err) {
     if (captured !== undefined && captured.layer === err)
         return httpVerdictOf(captured, () => renderedText(err), undefined, topCauseRecordOf(err, topCauseRead));
     const slots = readTurnErrorSlots(err, topStatusOf(err, ans), topCauseRead);
-    if (slots.status !== THROWN_SLOT_UNREADABLE && slots.name === 'StreamEndedWithoutTerminalError') {
+    if (slots.status !== THROWN_SLOT_UNREADABLE && isStreamEndedWithoutTerminalError(err)) {
         return noted({ kind: 'stream-ended-without-terminal' }, ans, captured, transportShapeOf(slots, err, ans), err, slots.errorCode, topCauseRead);
     }
     if (captured !== undefined) {

package/dist/wireFailureShape.d.ts

@@ -13,6 +13,8 @@ interface WireFailureShape {
 export declare const THROWN_SLOT_UNREADABLE: unique symbol;
 export declare function isSlotCarrier(x: {} | null | undefined): x is object;
 export declare function readThrownSlot(o: unknown, key: string, own?: boolean | 'data'): unknown;
+export declare function errnoCode(e: {} | null | undefined): string | undefined;
+export declare function thrownSlotOf(err: {} | null | undefined, name: string, kind?: boolean | 'data'): {} | null | undefined;
 export declare function thrownIsInstanceOf<C extends abstract new (...args: never[]) => unknown>(e: unknown, cls: C): e is InstanceType<C>;
 export type ThrownExtraReading = {
     readonly state: 'object';
@@ -27,6 +29,8 @@ export interface ThrownExtraSnapshot {
     readonly bag: ThrownExtraReading;
 }
 export declare function readThrownExtraSnapshot(o: {} | null | undefined): ThrownExtraSnapshot;
+export declare function liftLegacyRefusalFacts(code: {} | null | undefined, bag: object): object;
+export declare function placeThrownExtraOnCopy<V>(thrown: object, copy: object, copyBag: (bag: object) => V | undefined): 'placed' | 'not_placed' | 'place_failed';
 export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly ApprovalBindingMismatchError: "ApprovalBindingMismatchError";
     readonly ApprovalStaleError: "ApprovalStaleError";

package/dist/wireFailureShape.js

@@ -1,6 +1,7 @@
 import { msg, renderMessage } from './i18n/translate.js';
-import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
-import { RESUME_POLICY_FOLD_CODE } from './engineErrorCodes.js';
+import { guardedRead, ownDataField, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_TOOL_FACE_CONTROL, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USER_ATTACHMENT_INVALID_ERROR_CODE } from './engineErrorCodes.js';
+import { requestCoordinateText } from './requestCoordinate.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
 export function isSlotCarrier(x) {
     return (typeof x === 'object' && x !== null) || typeof x === 'function';
@@ -20,6 +21,13 @@ export function readThrownSlot(o, key, own = false) {
         return THROWN_SLOT_UNREADABLE;
     }
 }
+export function errnoCode(e) {
+    return guardedRead(() => readOwnDataNonEmptyString(e, 'code'));
+}
+export function thrownSlotOf(err, name, kind = false) {
+    const v = readThrownSlot(err, name, kind);
+    return v === THROWN_SLOT_UNREADABLE ? undefined : v;
+}
 function readGuarded(o, key) {
     const v = readThrownSlot(o, key);
     return v === THROWN_SLOT_UNREADABLE ? undefined : v;
@@ -117,7 +125,125 @@ export function readThrownExtraSnapshot(o) {
     catch {
         return { bag: { state: 'unreadable' } };
     }
-    return { bag: { state: 'object', value: slot } };
+    return { bag: { state: 'object', value: liftLegacyRefusalFacts(readThrownSlot(o, 'errorCode', 'data'), slot) } };
+}
+export function liftLegacyRefusalFacts(code, bag) {
+    try {
+        if (typeof code !== 'string')
+            return bag;
+        const dd = Object.getOwnPropertyDescriptor(bag, 'detail');
+        if (dd === undefined || !Object.hasOwn(dd, 'value'))
+            return bag;
+        const detail = dd.value;
+        if (typeof detail !== 'object' || detail === null || Array.isArray(detail))
+            return bag;
+        const moves = legacyRefusalMovesOf(code, bag, detail);
+        if (moves === undefined)
+            return bag;
+        const out = Object.create(null);
+        for (const key of Reflect.ownKeys(bag)) {
+            if (key === 'detail')
+                continue;
+            const d = Object.getOwnPropertyDescriptor(bag, key);
+            if (d !== undefined)
+                Object.defineProperty(out, key, { ...d, configurable: true });
+        }
+        for (const [key, value, override] of moves) {
+            if (!override && Object.getOwnPropertyDescriptor(out, key) !== undefined)
+                continue;
+            Object.defineProperty(out, key, { value, enumerable: true, writable: false, configurable: true });
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return bag;
+    }
+}
+const LEGACY_PROBLEMS_CODES = Object.freeze(['request.field_invalid', CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_TOOL_FACE_CONTROL, 'request.unprocessable', RESUME_POLICY_FOLD_CODE]);
+const LEGACY_HOOKS_KEYS = Object.freeze(['reason', 'event', 'alias', 'canonical', 'groupIndex', 'budgetMs', 'totalMs', 'type', 'key', 'count', 'cap']);
+function legacyRefusalMovesOf(code, bag, detail) {
+    const moves = [];
+    const take = (from, to = from, override = false) => {
+        const v = guardedRead(() => readOwnDataValue(detail, from));
+        if (v !== undefined)
+            moves.push([to, v, override]);
+    };
+    const rootField = guardedRead(() => readOwnDataValue(bag, 'field'));
+    if (code === 'request.field_invalid' && rootField === 'settings.hooks') {
+        for (const k of LEGACY_HOOKS_KEYS)
+            take(k);
+        const path = legacyHooksPathOf(detail);
+        if (path !== undefined)
+            moves.push(['field', requestCoordinateText(path[0] === 'hooks' ? 'settings' : 'settings.hooks', path), true]);
+        for (const k of ['problems', 'total', 'callerTrust'])
+            take(k);
+        return moves;
+    }
+    if (code === REQUEST_FIELD_CONFLICT) {
+        take('kind', 'reason');
+        for (const k of ['fields', 'count', 'cap'])
+            take(k);
+        return moves;
+    }
+    if (LEGACY_PROBLEMS_CODES.includes(code)) {
+        for (const k of ['problems', 'total', 'callerTrust'])
+            take(k);
+        return moves;
+    }
+    if (code === 'conflict.session_placed')
+        take('placement_kind');
+    else if (code === SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE)
+        for (const k of ['scenario', 'source'])
+            take(k);
+    else if (code === 'steering.duplicate_input_id')
+        take('differs');
+    else if (code === USER_ATTACHMENT_INVALID_ERROR_CODE) {
+        const path = guardedRead(() => readOwnDataValue(detail, 'path'));
+        if (typeof path === 'string' && path.length > 0)
+            moves.push(['field', path, false]);
+        const index = guardedRead(() => readOwnDataValue(detail, 'index'));
+        if (typeof index === 'number' && Number.isSafeInteger(index) && index >= 0)
+            moves.push(['index', index, false]);
+    }
+    else
+        return undefined;
+    return moves;
+}
+function legacyHooksPathOf(detail) {
+    try {
+        const raw = readOwnDataValue(detail, 'path');
+        if (!Array.isArray(raw) || raw.length === 0)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < raw.length; i++) {
+            if (!Object.hasOwn(raw, i))
+                return undefined;
+            const v = raw[i];
+            if (typeof v === 'string' || (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0))
+                out.push(v);
+            else
+                return undefined;
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function placeThrownExtraOnCopy(thrown, copy, copyBag) {
+    try {
+        const bag = readThrownExtraSnapshot(thrown).bag;
+        if (bag.state !== 'object')
+            return 'not_placed';
+        const value = copyBag(bag.value);
+        if (value === undefined)
+            return 'not_placed';
+        Object.defineProperty(copy, EXTRA_KEY, { value, writable: true, enumerable: true, configurable: true });
+        return 'placed';
+    }
+    catch {
+        return 'place_failed';
+    }
 }
 export const PROTOCOL_ERROR_NAME = Object.freeze({
     ApprovalBindingMismatchError: 'ApprovalBindingMismatchError',
@@ -472,24 +598,20 @@ export function readRefusalNamedFields(o) {
             out.push(v);
     };
     add(guardedRead(() => readRefusalField(o)));
-    const detail = guardedRead(() => readErrorRecord(o, 'detail'));
-    if (detail !== undefined) {
-        add(guardedRead(() => readOwnDataValue(detail, 'field')));
-        try {
-            const list = readOwnDataValue(detail, 'problems');
-            if (Array.isArray(list)) {
-                const n = list.length;
-                const len = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, REFUSAL_PROBLEMS_READ_MAX) : 0;
-                for (let i = 0; i < len; i += 1) {
-                    const item = guardedRead(() => readOwnDataValue(list, String(i)));
-                    if (typeof item !== 'object' || item === null)
-                        continue;
-                    add(guardedRead(() => readOwnDataValue(item, 'field')));
-                }
+    try {
+        const list = readErrorPresent(o, 'problems');
+        if (Array.isArray(list)) {
+            const n = list.length;
+            const len = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, REFUSAL_PROBLEMS_READ_MAX) : 0;
+            for (let i = 0; i < len; i += 1) {
+                const item = guardedRead(() => readOwnDataValue(list, String(i)));
+                if (typeof item !== 'object' || item === null)
+                    continue;
+                add(guardedRead(() => readOwnDataValue(item, 'field')));
             }
         }
-        catch {
-        }
+    }
+    catch {
     }
     return Object.freeze(out);
 }

package/dist/wireRefusalCopy.d.ts

@@ -108,28 +108,29 @@ export type HookMatcherRefusal = {
     readonly event: string;
     readonly alias: string;
     readonly canonical: string;
-    readonly path?: readonly (string | number)[];
+    readonly groupIndex?: number;
+    readonly field?: string;
 } | {
     readonly reason: 'invalid_regex';
     readonly event: string;
     readonly groupIndex: number;
-    readonly path?: readonly (string | number)[];
+    readonly field?: string;
 } | {
     readonly reason: 'over_budget';
     readonly event: string;
     readonly groupIndex: number;
     readonly budgetMs?: number;
-    readonly path?: readonly (string | number)[];
+    readonly field?: string;
 } | {
     readonly reason: 'budget_exceeded';
     readonly event: string;
     readonly groupIndex: number;
     readonly totalMs?: number;
-    readonly path?: readonly (string | number)[];
+    readonly field?: string;
 };
 export interface SettingsHooksRefusal {
     readonly reason: string;
-    readonly path?: readonly (string | number)[];
+    readonly field: string;
     readonly matcher?: HookMatcherRefusal;
     readonly count?: number;
     readonly cap?: number;