@sema-agent/client-core 0.101.0 → 0.103.0

package/dist/thinkingLatch.js

@@ -0,0 +1,255 @@
+import { readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { quoteUntrustedForSentence } from './displayUntrusted.js';
+import { seatCapabilityUnavailableDetail } from './seatContract.js';
+import { THINKING_LATCH_EVENTS, } from './thinkingLatchWords.js';
+const UNSET_WHYS = Object.freeze(['no_port', 'never_set', 'unreadable', 'malformed']);
+const THINKING_LATCH_TRANSITIONS = Object.freeze({
+    on: Object.freeze({ on: 'on', off: 'off', toggle: 'off', clear: 'unset' }),
+    off: Object.freeze({ on: 'on', off: 'off', toggle: 'on', clear: 'unset' }),
+    unset: Object.freeze({ on: 'on', off: 'off', toggle: 'off', clear: 'unset' }),
+});
+const storedOf = (state) => (state === 'on' ? true : state === 'off' ? false : undefined);
+const setReading = (state) => Object.freeze({ state });
+const unsetReading = (why) => Object.freeze({ state: 'unset', why });
+function normalizedReading(v) {
+    try {
+        if (typeof v !== 'object' || v === null)
+            return unsetReading('malformed');
+        const state = readOwnDataValue(v, 'state');
+        if (state === 'on' || state === 'off')
+            return setReading(state);
+        if (state !== 'unset')
+            return unsetReading('malformed');
+        const why = readOwnDataValue(v, 'why');
+        return typeof why === 'string' && UNSET_WHYS.includes(why) ? unsetReading(why) : unsetReading('malformed');
+    }
+    catch {
+        return unsetReading('malformed');
+    }
+}
+export function readThinkingLatch(port) {
+    if (port === undefined || port === null)
+        return unsetReading('no_port');
+    let stored;
+    try {
+        const read = port.read;
+        if (typeof read !== 'function')
+            return unsetReading('unreadable');
+        stored = Reflect.apply(read, port, []);
+    }
+    catch {
+        return unsetReading('unreadable');
+    }
+    if (stored === true)
+        return setReading('on');
+    if (stored === false)
+        return setReading('off');
+    if (stored === undefined)
+        return unsetReading('never_set');
+    return unsetReading('malformed');
+}
+export function writeThinkingLatch(port, event) {
+    if (port === undefined || port === null)
+        return Object.freeze({ kind: 'not_saved', why: 'no_port', previous: unsetReading('no_port') });
+    const previous = readThinkingLatch(port);
+    const ev = event;
+    if (typeof ev !== 'string' || !THINKING_LATCH_EVENTS.includes(ev)) {
+        return Object.freeze({ kind: 'not_saved', why: 'bad_event', previous });
+    }
+    const target = THINKING_LATCH_TRANSITIONS[previous.state][ev];
+    const clean = previous.why === undefined || previous.why === 'never_set';
+    if (clean && target === previous.state)
+        return Object.freeze({ kind: 'unchanged', state: target });
+    let wrote = false;
+    try {
+        const write = port.write;
+        if (typeof write === 'function') {
+            Reflect.apply(write, port, [storedOf(target)]);
+            wrote = true;
+        }
+    }
+    catch {
+        wrote = false;
+    }
+    if (!wrote)
+        return Object.freeze({ kind: 'not_saved', why: 'write_failed', attempted: target, now: readThinkingLatch(port) });
+    return Object.freeze({ kind: 'saved', previous, state: target });
+}
+const ownSlotOf = (v, key) => {
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        if (d === undefined)
+            return { kind: 'absent' };
+        return Object.hasOwn(d, 'value') ? { kind: 'data', value: d.value } : { kind: 'unreadable' };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+};
+function capabilityReadingOf(capability) {
+    if (typeof capability !== 'object' || capability === null)
+        return Object.freeze({ kind: 'malformed' });
+    const kind = ownSlotOf(capability, 'kind');
+    if (kind.kind !== 'data')
+        return Object.freeze({ kind: 'malformed' });
+    if (kind.value === 'not_reported')
+        return Object.freeze({ kind: 'not_reported' });
+    if (kind.value === 'reported') {
+        const available = ownSlotOf(capability, 'available');
+        return available.kind === 'data' && typeof available.value === 'boolean'
+            ? Object.freeze({ kind: 'reported', available: available.value })
+            : Object.freeze({ kind: 'malformed' });
+    }
+    return Object.freeze({ kind: 'malformed' });
+}
+const seatCarries = (capability) => {
+    try {
+        return seatCapabilityUnavailableDetail('thinkingLatch', capabilityReadingOf(capability)) === undefined;
+    }
+    catch {
+        return false;
+    }
+};
+const carrierBlocks = (carrier) => {
+    if (carrier.kind === 'absent')
+        return false;
+    if (carrier.kind === 'unreadable')
+        return true;
+    const c = carrier.value;
+    if (c === undefined)
+        return false;
+    if (typeof c !== 'object' || c === null)
+        return true;
+    const kind = ownSlotOf(c, 'kind');
+    if (kind.kind !== 'data')
+        return true;
+    if (kind.value === 'engine')
+        return false;
+    if (kind.value === 'seat') {
+        const capability = ownSlotOf(c, 'capability');
+        return capability.kind !== 'data' || !seatCarries(capability.value);
+    }
+    return true;
+};
+export function thinkingLatchView(reading, ctx) {
+    const r = normalizedReading(reading);
+    let carrier = { kind: 'absent' };
+    let modelSaysNoThinking = false;
+    if (ctx !== undefined && ctx !== null) {
+        if (typeof ctx !== 'object')
+            carrier = { kind: 'unreadable' };
+        else {
+            carrier = ownSlotOf(ctx, 'carrier');
+            const model = ownSlotOf(ctx, 'model');
+            if (model.kind === 'data' && typeof model.value === 'object' && model.value !== null) {
+                const mk = ownSlotOf(model.value, 'kind');
+                modelSaysNoThinking = mk.kind === 'data' && mk.value === 'not_applicable';
+            }
+        }
+    }
+    const conflict = carrierBlocks(carrier) ? 'seat_cannot_carry' : r.state === 'on' && modelSaysNoThinking ? 'model_cannot_think' : undefined;
+    return Object.freeze({ state: r.state, ...(r.why !== undefined ? { why: r.why } : {}), ...(conflict !== undefined ? { conflict } : {}) });
+}
+const MODEL_NAME_MAX = 120;
+const stateSentence = (state, lang) => state === 'on'
+    ? renderMessage(msg('session.thinking.state.on'), lang)
+    : state === 'off'
+        ? renderMessage(msg('session.thinking.state.off'), lang)
+        : state === 'unset'
+            ? renderMessage(msg('session.thinking.state.unset'), lang)
+            : undefined;
+export function thinkingLatchSentence(subject, lang) {
+    try {
+        if (typeof subject !== 'object' || subject === null)
+            return undefined;
+        const kind = readOwnDataValue(subject, 'kind');
+        if (kind === 'state')
+            return stateSentence(readOwnDataValue(subject, 'state'), lang);
+        if (kind === 'turn') {
+            const p = readOwnDataValue(subject, 'projection');
+            if (typeof p !== 'object' || p === null)
+                return undefined;
+            return readOwnDataValue(p, 'verdict') === 'off' && readOwnDataValue(p, 'ultracodeStamped') === true
+                ? renderMessage(msg('session.thinking.offWithUltracodeOnBody'), lang)
+                : undefined;
+        }
+        if (kind === 'view') {
+            const view = readOwnDataValue(subject, 'view');
+            if (typeof view !== 'object' || view === null)
+                return undefined;
+            const conflict = readOwnDataValue(view, 'conflict');
+            if (conflict === 'seat_cannot_carry') {
+                const carrier = readOwnDataValue(subject, 'carrier');
+                const capability = typeof carrier === 'object' && carrier !== null && readOwnDataValue(carrier, 'kind') === 'seat'
+                    ? readOwnDataValue(carrier, 'capability')
+                    : undefined;
+                return seatCapabilityUnavailableDetail('thinkingLatch', capabilityReadingOf(capability));
+            }
+            if (conflict === 'model_cannot_think') {
+                const model = readOwnDataValue(subject, 'model');
+                const shown = typeof model === 'string' && model.length > 0 ? quoteUntrustedForSentence(model, MODEL_NAME_MAX) : undefined;
+                return shown === undefined ? undefined : renderMessage(msg('session.thinking.modelCannotThink', { model: shown }), lang);
+            }
+            if (conflict !== undefined)
+                return undefined;
+            const r = normalizedReading(view);
+            if (r.why === 'unreadable' || r.why === 'malformed')
+                return renderMessage(msg('session.thinking.storeUnreadable'), lang);
+            return stateSentence(r.state, lang);
+        }
+        if (kind === 'write') {
+            const outcome = readOwnDataValue(subject, 'outcome');
+            if (typeof outcome !== 'object' || outcome === null)
+                return undefined;
+            return readOwnDataValue(outcome, 'kind') === 'not_saved' ? renderMessage(msg('session.thinking.notSaved'), lang) : undefined;
+        }
+        if (kind === 'seat_ack') {
+            const ack = readOwnDataValue(subject, 'ack');
+            if (typeof ack !== 'object' || ack === null)
+                return undefined;
+            return readOwnDataValue(ack, 'ok') === false ? renderMessage(msg('session.thinking.notSaved'), lang) : undefined;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function thinkingLatchRowWordOf(reading) {
+    const r = normalizedReading(reading);
+    if (r.state === 'on' || r.state === 'off')
+        return r.state;
+    if (r.why === 'unreadable')
+        return 'unreadable';
+    if (r.why === 'malformed')
+        return 'malformed';
+    return undefined;
+}
+export function readSeatThinkingLatch(record, capability) {
+    if (!seatCarries(capability))
+        return unsetReading('no_port');
+    const row = record;
+    if (row === undefined || row === null)
+        return unsetReading('no_port');
+    try {
+        if (typeof row !== 'object')
+            return unsetReading('malformed');
+        const d = Object.getOwnPropertyDescriptor(row, 'thinkingLatch');
+        if (d === undefined)
+            return unsetReading('never_set');
+        if (!Object.hasOwn(d, 'value'))
+            return unsetReading('malformed');
+        const w = d.value;
+        if (w === undefined)
+            return unsetReading('never_set');
+        if (w === 'on' || w === 'off')
+            return setReading(w);
+        if (w === 'unreadable')
+            return unsetReading('unreadable');
+        return unsetReading('malformed');
+    }
+    catch {
+        return unsetReading('unreadable');
+    }
+}

package/dist/thinkingLatchWords.d.ts

@@ -0,0 +1,7 @@
+export declare const THINKING_LATCH_STATES: readonly ["on", "off", "unset"];
+export type ThinkingLatchState = (typeof THINKING_LATCH_STATES)[number];
+export declare const THINKING_LATCH_SET_STATES: readonly ["on", "off"];
+export declare const THINKING_LATCH_EVENTS: readonly ["on", "off", "toggle", "clear"];
+export type ThinkingLatchEvent = (typeof THINKING_LATCH_EVENTS)[number];
+export declare const THINKING_LATCH_ROW_WORDS: readonly ["on", "off", "unreadable", "malformed"];
+export type ThinkingLatchRowWord = (typeof THINKING_LATCH_ROW_WORDS)[number];

package/dist/thinkingLatchWords.js

@@ -0,0 +1,4 @@
+export const THINKING_LATCH_STATES = Object.freeze(['on', 'off', 'unset']);
+export const THINKING_LATCH_SET_STATES = Object.freeze(['on', 'off']);
+export const THINKING_LATCH_EVENTS = Object.freeze(['on', 'off', 'toggle', 'clear']);
+export const THINKING_LATCH_ROW_WORDS = Object.freeze(['on', 'off', 'unreadable', 'malformed']);

package/dist/toolResult.js

@@ -4,7 +4,7 @@ import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
 import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
-import { guardedRead, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, } from './ownKey.js';
+import { guardedRead, ownDataField, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf, } from './ownKey.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
@@ -285,29 +285,7 @@ const TOOL_CARD_DEGRADED_TEXT = {
     unrecognised: 'This tool call carries a result marker this client does not recognise, so no result is shown for it.',
 };
 const cardDegraded = (cause) => ({ kind: 'degraded', cause, text: TOOL_CARD_DEGRADED_TEXT[cause] });
-function cardOwnData(o, key) {
-    const d = Object.getOwnPropertyDescriptor(o, key);
-    if (d === undefined)
-        return undefined;
-    if (!Object.hasOwn(d, 'value'))
-        throw new TypeError(`own property "${key}" is an accessor`);
-    return d.value;
-}
 const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-function toolResultBlockOf(record) {
-    const message = cardOwnData(record, 'message');
-    if (!isCardRecordObject(message))
-        return undefined;
-    const content = cardOwnData(message, 'content');
-    if (!Array.isArray(content))
-        return undefined;
-    for (let i = 0; i < content.length; i++) {
-        const block = cardOwnData(content, String(i));
-        if (isCardRecordObject(block) && cardOwnData(block, 'type') === 'tool_result')
-            return block;
-    }
-    return undefined;
-}
 export function readToolCardOutcome(record) {
     try {
         if (!isCardRecordObject(record))
@@ -327,7 +305,7 @@ export function readToolCardOutcome(record) {
             return { kind: 'unreadable' };
         if (markerDesc.value !== TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT)
             return cardDegraded('unrecognised');
-        return cardDegraded(cardOwnData(block, 'is_error') === true ? 'error-without-detail' : 'no-result');
+        return cardDegraded(ownDataField(block, 'is_error') === true ? 'error-without-detail' : 'no-result');
     }
     catch {
         return { kind: 'unreadable' };

package/dist/turnFailurePresentation.js

@@ -60,7 +60,14 @@ 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]);
+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 BROWSER_FETCH_FAILURE = /\bfailed to fetch\b|\bnetworkerror\b|\bnetwork error\b|\bload failed\b/i;
 function httpShapeOf(verdict, code) {
     const status = verdict.status;

package/dist/wireFailureShape.d.ts

@@ -23,6 +23,11 @@ export type ThrownExtraReading = {
     readonly state: 'unreadable';
 };
 export declare function readThrownExtra(o: {} | null | undefined): ThrownExtraReading;
+export interface ThrownExtraSnapshot {
+    readonly sdkInstance: boolean;
+    readonly bag: ThrownExtraReading;
+}
+export declare function readThrownExtraSnapshot(o: {} | null | undefined): ThrownExtraSnapshot;
 export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly ApprovalBindingMismatchError: "ApprovalBindingMismatchError";
     readonly ApprovalStaleError: "ApprovalStaleError";
@@ -53,7 +58,7 @@ export type ProtocolErrorNameReading = {
 } | {
     readonly state: 'unreadable';
 };
-export declare function protocolErrorNameReading(e: object): ProtocolErrorNameReading;
+export declare function protocolErrorNameReading(e: object, extra?: ThrownExtraSnapshot): ProtocolErrorNameReading;
 export declare function protocolErrorNameOf(e: object): ProtocolErrorName | undefined;
 export type ThrownStatusReading = number | undefined | typeof THROWN_SLOT_UNREADABLE;
 export declare function readThrownStatusSlot(o: object, notePresence?: (presence: SlotPresence) => void): ThrownStatusReading;
@@ -66,6 +71,7 @@ export declare function slotPresenceOf(o: object, key: string): SlotPresence;
 export declare function slotReadOf(o: object, key: string): OwnSlotRead;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
+export declare function readErrorPresent(o: object, key: string): {} | null | undefined;
 export declare function readErrorString(o: object, key: string): string | undefined;
 export declare function readErrorStringList(o: object, key: string): readonly string[] | undefined;
 export declare function readErrorStrictStringList(o: object, key: string): readonly string[] | undefined;
@@ -106,6 +112,11 @@ export declare function ownFoldedCodeBitsOf(wire: {
     readonly blockedBy?: string;
 } | undefined): FoldedCodeBits;
 export declare function readRefusalField(o: object): string | undefined;
+export interface RefusalSlotReading {
+    readonly word: string | undefined;
+    readonly present: boolean;
+}
+export declare function readRefusalSlots<K extends string>(o: object, keys: readonly K[], bag?: ThrownExtraReading): Readonly<Record<K, RefusalSlotReading>>;
 export declare const REFUSAL_PROBLEMS_READ_MAX = 1000;
 export declare function readRefusalNamedFields(o: object): readonly string[];
 export declare function isDisplayableWireCode(s: string): boolean;

package/dist/wireFailureShape.js

@@ -87,28 +87,38 @@ function isBuiltinErrorPrototype(node) {
     return ['message', 'name', 'toString'].every((k) => Object.getOwnPropertyDescriptor(node, k) !== undefined);
 }
 export function readThrownExtra(o) {
+    return readThrownExtraSnapshot(o).bag;
+}
+export function readThrownExtraSnapshot(o) {
     if (o === null || o === undefined || (typeof o !== 'object' && typeof o !== 'function'))
-        return { state: 'absent' };
+        return { sdkInstance: false, bag: { state: 'absent' } };
+    let at;
+    try {
+        at = extraSlotOf(o);
+    }
+    catch {
+        return { sdkInstance: false, bag: { state: 'unreadable' } };
+    }
+    const sdkInstance = at.kind === 'sdk-class';
+    if (at.kind === 'own-accessor')
+        return { sdkInstance, bag: { state: 'unreadable' } };
+    if (at.kind === 'none')
+        return { sdkInstance, bag: { state: 'absent' } };
     let slot;
     try {
-        const at = extraSlotOf(o);
-        if (at.kind === 'own-accessor')
-            return { state: 'unreadable' };
-        if (at.kind === 'none')
-            return { state: 'absent' };
         slot = at.kind === 'own-data' ? at.value : Reflect.get(o, EXTRA_KEY);
     }
     catch {
-        return { state: 'unreadable' };
+        return { sdkInstance, bag: { state: 'unreadable' } };
     }
     try {
         if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
-            return { state: 'absent' };
+            return { sdkInstance, bag: { state: 'absent' } };
     }
     catch {
-        return { state: 'unreadable' };
+        return { sdkInstance, bag: { state: 'unreadable' } };
     }
-    return { state: 'object', value: slot };
+    return { sdkInstance, bag: { state: 'object', value: slot } };
 }
 export const PROTOCOL_ERROR_NAME = Object.freeze({
     ApprovalBindingMismatchError: 'ApprovalBindingMismatchError',
@@ -137,11 +147,11 @@ export function isSdkErrorInstance(o) {
         return false;
     }
 }
-export function protocolErrorNameReading(e) {
+export function protocolErrorNameReading(e, extra) {
     if (typeof e !== 'object' || e === null)
         return { state: 'absent' };
     try {
-        if (isSdkErrorInstance(e))
+        if (extra !== undefined ? extra.sdkInstance : 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' };
@@ -221,6 +231,10 @@ export function readErrorRecord(o, key) {
     const v = readErrorSlot(o, key, (x) => typeof x === 'object' && x !== null && !Array.isArray(x));
     return typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined;
 }
+export function readErrorPresent(o, key) {
+    const v = readErrorSlot(o, key, (x) => x !== undefined);
+    return v === undefined ? undefined : v;
+}
 export function readErrorString(o, key) {
     const v = readErrorSlot(o, key, (x) => typeof x === 'string');
     return typeof v === 'string' ? v : undefined;
@@ -396,18 +410,38 @@ export function ownFoldedCodeBitsOf(wire) {
     return Object.freeze({ errorCode: bit('errorCode'), blockedBy: bit('blockedBy') });
 }
 export function readRefusalField(o) {
-    const str = (rec) => {
-        const v = guardedRead(() => readOwnDataValue(rec, 'field'));
-        return typeof v === 'string' && v !== '' ? v : undefined;
-    };
-    const reading = readThrownExtra(o);
-    if (reading.state === 'object') {
-        const fromExtra = str(reading.value);
-        if (fromExtra !== undefined)
-            return fromExtra;
-    }
-    const top = readThrownSlot(o, 'field', 'data');
-    return typeof top === 'string' && top !== '' ? top : undefined;
+    return readRefusalSlots(o, REFUSAL_FIELD_ONLY).field.word;
+}
+const REFUSAL_SLOT_ABSENT = Object.freeze({ word: undefined, present: false });
+const REFUSAL_SLOT_HELD_UNREADABLE = Object.freeze({ word: undefined, present: true });
+const REFUSAL_FIELD_ONLY = Object.freeze(['field']);
+function refusalSlotOf(container, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(container, key);
+        if (d === undefined)
+            return REFUSAL_SLOT_ABSENT;
+        if (!Object.hasOwn(d, 'value'))
+            return REFUSAL_SLOT_HELD_UNREADABLE;
+        const v = d.value;
+        if (v === undefined)
+            return REFUSAL_SLOT_ABSENT;
+        return typeof v === 'string' && v !== '' ? Object.freeze({ word: v, present: true }) : REFUSAL_SLOT_HELD_UNREADABLE;
+    }
+    catch {
+        return REFUSAL_SLOT_HELD_UNREADABLE;
+    }
+}
+export function readRefusalSlots(o, keys, bag = readThrownExtra(o)) {
+    const carrier = isSlotCarrier(o);
+    const out = Object.create(null);
+    for (const key of keys) {
+        const fromBag = bag.state === 'object' ? refusalSlotOf(bag.value, key) : REFUSAL_SLOT_ABSENT;
+        const top = carrier ? refusalSlotOf(o, key) : REFUSAL_SLOT_ABSENT;
+        const word = fromBag.word ?? top.word;
+        const present = bag.state === 'unreadable' || fromBag.present || top.present;
+        out[key] = word === undefined && !present ? REFUSAL_SLOT_ABSENT : Object.freeze({ word, present });
+    }
+    return Object.freeze(out);
 }
 export const REFUSAL_PROBLEMS_READ_MAX = 1000;
 export function readRefusalNamedFields(o) {

package/dist/wireRefusalCopy.d.ts

@@ -126,7 +126,6 @@ export type HookMatcherRefusal = {
     readonly totalMs?: number;
     readonly path?: readonly (string | number)[];
 };
-export declare function hookMatcherRefusalFromError(err: unknown): HookMatcherRefusal | undefined;
 export interface SettingsHooksRefusal {
     readonly reason: string;
     readonly path?: readonly (string | number)[];
@@ -159,11 +158,9 @@ export interface UserAttachmentRefusalDetail {
     readonly path?: string;
 }
 export declare function userAttachmentRefusalFromError(err: {} | null | undefined): UserAttachmentRefusalDetail | null;
-export declare function userAttachmentRefusalContent(detail?: Pick<UserAttachmentRefusalDetail, 'index'>): 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;
 export {};

package/dist/wireRefusalCopy.js

@@ -4,7 +4,6 @@ import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_L
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
-import { prepareRefusalNoteOf } from './prepareRefusal.js';
 import { PERMISSION_RULE_ISSUE_CODES, permissionRuleIssueDetail } from './permissionRuleIssue.js';
 import { ruleRefusalListText } from './ruleRefusalSentence.js';
 import { msg, renderMessage } from './i18n/translate.js';
@@ -734,9 +733,6 @@ export function hostPostureRefusalContent(detail, lang) {
     }
 }
 const HOOK_MATCHER_REFUSAL_FIELD = 'settings.hooks';
-export function hookMatcherRefusalFromError(err) {
-    return settingsHooksRefusalFromError(err)?.matcher;
-}
 function hooksRefusalPathOf(detail) {
     try {
         const raw = readOwnDataValue(detail, 'path');
@@ -979,19 +975,6 @@ export function userAttachmentRefusalFromError(err) {
         return null;
     }
 }
-export function userAttachmentRefusalContent(detail) {
-    let index;
-    try {
-        index = detail === undefined || detail === null ? undefined : detail.index;
-    }
-    catch {
-        index = undefined;
-    }
-    return prepareRefusalNoteOf(USER_ATTACHMENT_INVALID_ERROR_CODE, typeof index === 'number' ? { index } : undefined);
-}
 export function userInvokedSkillRefusalFromError(err) {
     return effectiveWireErrorCode(err) === USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE ? { code: USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, retryable: false } : null;
 }
-export function userInvokedSkillRefusalContent() {
-    return prepareRefusalNoteOf(USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE);
-}