@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/storePostureCapability.js

@@ -3,6 +3,8 @@ import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
+import { readStoreDurability } from './storeDurabilityWord.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 export function projectStorePostureCapability(caps) {
     try {
@@ -21,8 +23,8 @@ function projectStorePostureOf(caps) {
     const store = seat.store;
     const declared = ownDataField(store, 'declared');
     const backend = ownDataField(store, 'backend');
-    const durable = ownDataField(store, 'durable');
-    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+    const durability = durabilityOf(store, 'wire');
+    if (!nonEmpty(declared) || !nonEmpty(backend) || durability.kind === 'malformed')
         return undefined;
     const reason = ownDataField(store, 'degradedReason');
     if (reason !== undefined && !nonEmpty(reason))
@@ -35,12 +37,44 @@ function projectStorePostureOf(caps) {
         view: {
             declared,
             backend,
-            durable,
+            ...(durability.kind === 'legacy' ? { durable: durability.durable } : {}),
+            ...(durability.kind === 'word' ? { durability: durability.durability } : {}),
+            ...(durability.kind === 'unrecognized' ? { unrecognizedDurability: durability.word } : {}),
             ...(nonEmpty(reason) ? { degradedReason: reason } : {}),
             ...(sqlReading.kind === 'present' ? { sql: sqlReading.view } : {}),
         },
     };
 }
+const MALFORMED_DURABILITY = Object.freeze({ kind: 'malformed' });
+function durabilityOf(section, side) {
+    try {
+        const word = readStoreDurability(section);
+        const durable = ownDataField(section, 'durable');
+        const unrecognized = side === 'view' ? ownDataField(section, 'unrecognizedDurability') : undefined;
+        const present = (word.kind === 'absent' ? 0 : 1) + (durable === undefined ? 0 : 1) + (unrecognized === undefined ? 0 : 1);
+        if (present !== 1)
+            return MALFORMED_DURABILITY;
+        if (word.kind === 'word')
+            return { kind: 'word', durability: word.durability };
+        if (word.kind === 'unrecognized')
+            return { kind: 'unrecognized', word: word.word };
+        if (typeof durable === 'boolean')
+            return { kind: 'legacy', durable };
+        if (nonEmpty(unrecognized))
+            return { kind: 'unrecognized', word: unrecognized };
+        return MALFORMED_DURABILITY;
+    }
+    catch {
+        return MALFORMED_DURABILITY;
+    }
+}
+function persistenceOf(d) {
+    if (d.kind === 'legacy')
+        return d.durable ? 'durable' : 'not_durable';
+    if (d.kind !== 'word')
+        return 'unknown';
+    return d.durability === 'durable' ? 'durable' : d.durability === 'ephemeral' ? 'not_durable' : 'unknown';
+}
 const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
@@ -70,58 +104,54 @@ export function storePersistence(reading) {
     const r = presentView(reading);
     if (r?.kind !== 'present')
         return 'unknown';
-    let durable;
-    try {
-        durable = r.view.durable;
-    }
-    catch {
-        return 'unknown';
-    }
-    return durable === true ? 'durable' : durable === false ? 'not_durable' : 'unknown';
+    return persistenceOf(durabilityOf(r.view, 'view'));
 }
-const STORE_NOT_DURABLE_HEAD = 'NOT durable';
-export function storePostureHeadWord(reading) {
-    return storePersistence(reading) === 'not_durable' ? STORE_NOT_DURABLE_HEAD : undefined;
+const notDurableHead = () => msg('notice.capability.storePosture.notDurableHead');
+export function storePostureHeadWord(reading, lang) {
+    return storePersistence(reading) === 'not_durable' ? renderMessage(notDurableHead(), lang) : undefined;
 }
 const WORD_DETAIL_MAX = 40;
 const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
-export function storePostureDoctorDetail(reading) {
-    const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
+export function storePostureDoctorDetail(reading, lang) {
+    const say = (ref) => renderMessage(ref, lang);
+    const unobserved = msg('notice.capability.storePosture.unobserved');
     const r = presentView(reading);
     if (r?.kind === 'unreadable')
-        return unreadableReadingDetail('store posture');
-    if (r?.kind === 'not_reported') {
-        return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
-    }
+        return unreadableReadingDetail(say(msg('notice.capability.subject.storePosture')), lang);
+    if (r?.kind === 'not_reported')
+        return say(msg('notice.capability.storePosture.notReported'));
     if (r?.kind !== 'present')
-        return unobserved;
+        return say(unobserved);
     let declared;
     let backend;
-    let durable;
     let reason;
     try {
         declared = r.view.declared;
         backend = r.view.backend;
-        durable = r.view.durable;
         reason = r.view.degradedReason;
     }
     catch {
-        return unobserved;
-    }
-    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
-        return unobserved;
-    const assembled = declared === backend ? `store ${word(backend)}` : `store declared ${word(declared)}, running on ${word(backend)}`;
-    if (durable) {
-        return `${assembled} — durable: this replica persists its state, so it survives a restart`;
+        return say(unobserved);
     }
-    const lost = `${STORE_NOT_DURABLE_HEAD}: this replica holds its state in memory and loses it on restart`;
+    const durability = durabilityOf(r.view, 'view');
+    if (!nonEmpty(declared) || !nonEmpty(backend) || durability.kind === 'malformed')
+        return say(unobserved);
+    const assembled = declared === backend
+        ? msg('notice.capability.storePosture.assembled', { backend: word(backend) })
+        : msg('notice.capability.storePosture.assembledDeclared', { declared: word(declared), backend: word(backend) });
+    if (durability.kind === 'unrecognized')
+        return say(msg('notice.capability.storePosture.unrecognized', { assembled, word: word(durability.word) }));
+    const persistence = persistenceOf(durability);
+    if (persistence === 'durable')
+        return say(msg('notice.capability.storePosture.durable', { assembled }));
+    if (persistence === 'unknown')
+        return say(msg('notice.capability.storePosture.unknown', { assembled }));
+    const line = msg(durability.kind === 'legacy' ? 'notice.capability.storePosture.memory' : 'notice.capability.storePosture.ephemeral', { assembled, head: notDurableHead() });
     if (!nonEmpty(reason))
-        return `${assembled} — ${lost}`;
-    if (reason === 'db_unreachable') {
-        return `${assembled} — ${lost} (degraded: the declared database could not be opened at start-up, so the engine fell back rather than refusing to start)`;
-    }
-    if (reason === 'local_unwritable') {
-        return `${assembled} — ${lost} (degraded: the default local file store could not be created — a read-only or full data directory is one possible cause, and this client cannot tell which applies)`;
-    }
-    return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
+        return say(line);
+    if (reason === 'db_unreachable')
+        return say(msg('notice.capability.storePosture.degraded.dbUnreachable', { line }));
+    if (reason === 'local_unwritable')
+        return say(msg('notice.capability.storePosture.degraded.localUnwritable', { line }));
+    return say(msg('notice.capability.storePosture.degraded.other', { line, reason: word(reason) }));
 }

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/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;