@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/wireRefusalCopy.js

@@ -1,9 +1,11 @@
 import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 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 { msg, renderMessage } from './i18n/translate.js';
 export const CONFLICT_APPROVAL_SETTLED = 'conflict.approval_settled';
 export const CONFLICT_RUN_NOT_RUNNING = 'conflict.run_not_running';
 function ownNonEmptyStringSlot(o, key) {
@@ -25,17 +27,14 @@ export function cancelConflictFromError(err) {
         return { kind: 'run_not_running', code };
     return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
 }
-export function cancelConflictContent(detail) {
+export function cancelConflictContent(detail, lang) {
     switch (detail.kind) {
         case 'approval_settled':
-            return ('The cancel did not apply: the approval this task was waiting on has already been decided or has expired elsewhere · ' +
-                'Check what that decision did to the task before doing anything else');
+            return renderMessage(msg('notice.wireRefusal.cancel.approvalSettled'), lang);
         case 'run_not_running':
-            return ('The cancel could not be set: the task kept switching between running and waiting while the engine tried · ' +
-                'Nothing was changed — send the cancel again');
+            return renderMessage(msg('notice.wireRefusal.cancel.runNotRunning'), lang);
         case 'unrecognized':
-            return ('The engine refused this cancel with a conflict it did not explain · ' +
-                'The task may have just been decided elsewhere, or may have changed state mid-cancel — check its current state, then cancel again if it is still active');
+            return renderMessage(msg('notice.wireRefusal.cancel.unrecognized'), lang);
     }
 }
 function nonNegativeFinite(v) {
@@ -79,11 +78,11 @@ function humanWait(sec) {
     const mm = m % 60;
     return mm === 0 ? `${h} h` : `${h} h ${mm} min`;
 }
-export function usageWindowExhaustedContent(detail) {
-    const head = "The deployment's usage window is exhausted, so the engine did not accept this request · Nothing is wrong with the request itself";
+export function usageWindowExhaustedContent(detail, lang) {
+    const head = renderMessage(msg('notice.wireRefusal.usageWindow.head'), lang);
     return detail.retryAfterSec !== undefined
-        ? `${head} · Send it again in about ${humanWait(detail.retryAfterSec)}`
-        : `${head} · The engine did not say how long the window needs — send it again a little later`;
+        ? `${head} · ${renderMessage(msg('notice.wireRefusal.sendAgainAbout', { wait: humanWait(detail.retryAfterSec) }), lang)}`
+        : `${head} · ${renderMessage(msg('notice.wireRefusal.usageWindow.unknownWait'), lang)}`;
 }
 const positiveFinite = (v) => typeof v === 'number' && Number.isFinite(v) && v > 0;
 export function fleetLeaseUnavailableFromError(err) {
@@ -111,7 +110,7 @@ export function fleetLeaseUnavailableFromError(err) {
         ...(sec !== undefined ? { retryAfterSec: sec } : {}),
     };
 }
-export function fleetLeaseUnavailableContent(detail) {
+export function fleetLeaseUnavailableContent(detail, lang) {
     let reason;
     let sec;
     try {
@@ -126,46 +125,17 @@ export function fleetLeaseUnavailableContent(detail) {
     catch {
         sec = undefined;
     }
-    const head = "This deployment could not confirm your usage budget with its quota service, and it refuses billed work while it cannot check, so the engine did not accept this request · Nothing is wrong with the request itself";
+    const head = renderMessage(msg('notice.wireRefusal.fleetLease.head'), lang);
     const cause = reason === 'auth-rejected'
-        ? " · The quota service rejected this engine's credentials — if this keeps happening, whoever operates the engine needs to fix them"
+        ? ` · ${renderMessage(msg('notice.wireRefusal.fleetLease.authRejected'), lang)}`
         : reason === 'unreachable'
-            ? ' · The engine could not reach the quota service'
+            ? ` · ${renderMessage(msg('notice.wireRefusal.fleetLease.unreachable'), lang)}`
             : '';
     const wait = positiveFinite(sec)
-        ? ` · Send it again in about ${humanWait(Math.ceil(sec))}`
-        : ' · The engine did not say how long to wait — send it again a little later';
+        ? ` · ${renderMessage(msg('notice.wireRefusal.sendAgainAbout', { wait: humanWait(Math.ceil(sec)) }), lang)}`
+        : ` · ${renderMessage(msg('notice.wireRefusal.fleetLease.unknownWait'), lang)}`;
     return `${head}${cause}${wait}`;
 }
-export function scenarioAssignmentUnknownFromError(err) {
-    try {
-        if (err === null || typeof err !== 'object')
-            return null;
-        if (effectiveWireErrorCode(err) !== SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE)
-            return null;
-        const detail = readErrorRecord(err, 'detail');
-        const bit = (key) => {
-            if (detail === undefined)
-                return undefined;
-            try {
-                return Object.hasOwn(detail, key) ? detail[key] : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const scenario = bit('scenario');
-        const source = bit('source');
-        return {
-            code: SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
-            ...(typeof scenario === 'string' && scenario.length > 0 ? { scenario } : {}),
-            ...(source === 'ruling' || source === 'deployment' ? { source } : {}),
-        };
-    }
-    catch {
-        return null;
-    }
-}
 const SETTLED_BY_NOT_IN_PROOF = 'settled_by_not_in_proof';
 const DECIDED_BY_NOT_IN_PROOF = 'decided_by_not_in_proof';
 const RETIRED_DECISION_KEY = 'settledBy';
@@ -202,26 +172,19 @@ export function denyAttributionRefusalFromError(err, sentAttributionKey) {
         return null;
     }
 }
-export function denyAttributionRefusalContent(detail) {
+export function denyAttributionRefusalContent(detail, lang) {
     switch (detail.kind) {
         case 'not_in_proof':
-            return ('The engine refused this refusal before judging it: this deployment signs the decisions it accepts, and the note saying ' +
-                'who settled this one is not part of what gets signed · Nothing was decided and the approval is still waiting — ' +
-                'send the same decision again without that note');
+            return renderMessage(msg('notice.wireRefusal.denyAttribution.notInProof'), lang);
         case 'decision_conflict':
-            return ('The engine refused this decision before judging it: the body says a policy settled it and also asks to allow the call, ' +
-                'and only a person can allow one · Nothing was decided and the approval is still waiting — ' +
-                'send it again with the decision and the note in agreement');
+            return renderMessage(msg('notice.wireRefusal.denyAttribution.decisionConflict'), lang);
         case 'retired_key':
-            return ('The engine refused this decision before judging it: the note saying who settled it was sent under a name this engine no longer accepts · ' +
-                'Nothing was decided and the approval is still waiting — send the decision again with who made it given under the name the engine now takes in its place');
+            return renderMessage(msg('notice.wireRefusal.denyAttribution.retiredKey'), lang);
         case 'attribution_rejected': {
             const named = typeof detail.field === 'string' && APPROVAL_NON_BINDING_FIELDS.has(detail.field)
-                ? ` It named ${detail.field} as the part it would not take.`
+                ? renderMessage(msg('notice.wireRefusal.denyAttribution.named', { field: detail.field }), lang)
                 : '';
-            return ('The engine would not accept the settlement details this decision carried, so it refused the decision before judging it.' +
-                `${named} · Nothing was decided and the approval is still waiting at the same coordinates — ` +
-                'check what that part carried (the only piece this client sets is the note saying who settled the refusal) and decide once more');
+            return renderMessage(msg('notice.wireRefusal.denyAttribution.attributionRejected', { named }), lang);
         }
     }
 }
@@ -252,36 +215,36 @@ export function sessionDeleteConflictFromError(err) {
 }
 const DELETE_CONFLICT_IDS_SHOWN = 3;
 const DELETE_CONFLICT_ID_MAX = 64;
-function sessionDeleteConflictUnrecognizedContent() {
-    return ('The engine refused to delete this session with a conflict it did not explain · ' +
-        'Check whether the session is still listed and whether anything of it is still running, then try the delete again');
+function sessionDeleteConflictUnrecognizedContent(lang) {
+    return renderMessage(msg('notice.wireRefusal.sessionDelete.unrecognized'), lang);
 }
-export function sessionDeleteConflictContent(detail) {
+export function sessionDeleteConflictContent(detail, lang) {
     try {
         if (detail === null || typeof detail !== 'object')
-            return sessionDeleteConflictUnrecognizedContent();
+            return sessionDeleteConflictUnrecognizedContent(lang);
         switch (detail.kind) {
             case 'children_alive': {
                 const raw = detail.remaining;
                 const ids = Array.isArray(raw) ? raw.filter((id) => typeof id === 'string' && id.length > 0) : [];
                 const shown = ids.slice(0, DELETE_CONFLICT_IDS_SHOWN).map((id) => capForDisplay(id, DELETE_CONFLICT_ID_MAX));
-                const more = ids.length > shown.length ? ` and ${ids.length - shown.length} more` : '';
-                const which = shown.length > 0 ? ` (${shown.join(', ')}${more})` : '';
-                return (`This session was not deleted: background agents it started are still running where this engine cannot stop them${which} · ` +
-                    'Nothing was deleted — delete it again once they finish, or stop them where they run first');
+                const which = shown.length === 0
+                    ? ''
+                    : ids.length > shown.length
+                        ? renderMessage(msg('notice.wireRefusal.sessionDelete.whichMore', { ids: shown.join(', '), count: ids.length - shown.length }), lang)
+                        : renderMessage(msg('notice.wireRefusal.sessionDelete.which', { ids: shown.join(', ') }), lang);
+                return renderMessage(msg('notice.wireRefusal.sessionDelete.childrenAlive', { which }), lang);
             }
             case 'active_run': {
                 const active = detail.activeTaskId;
-                const run = typeof active === 'string' && active.length > 0 ? ` (run ${capForDisplay(active, DELETE_CONFLICT_ID_MAX)})` : '';
-                return (`This session was not deleted: it still has a run in progress${run} · ` +
-                    'Nothing was deleted — cancel that run or let it finish, then delete the session again');
+                const run = typeof active === 'string' && active.length > 0 ? renderMessage(msg('notice.wireRefusal.sessionDelete.runId', { id: capForDisplay(active, DELETE_CONFLICT_ID_MAX) }), lang) : '';
+                return renderMessage(msg('notice.wireRefusal.sessionDelete.activeRun', { run }), lang);
             }
             default:
-                return sessionDeleteConflictUnrecognizedContent();
+                return sessionDeleteConflictUnrecognizedContent(lang);
         }
     }
     catch {
-        return sessionDeleteConflictUnrecognizedContent();
+        return sessionDeleteConflictUnrecognizedContent(lang);
     }
 }
 const FIELD_INVALID = 'request.field_invalid';
@@ -293,6 +256,24 @@ const BUCKET_OF_FIELD = Object.freeze({
 const nonNegInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined);
 const posInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 1 ? v : undefined);
 export function settingsPermissionBucketRefusalFromError(err) {
+    const r = fieldLimitRefusalFromError(err);
+    if (r === null)
+        return null;
+    const bucket = Object.hasOwn(BUCKET_OF_FIELD, r.field) ? BUCKET_OF_FIELD[r.field] : undefined;
+    if (bucket === undefined || (r.reason !== 'over_cap' && r.reason !== 'bad_entry'))
+        return null;
+    if (r.reason === 'over_cap') {
+        return Object.freeze({
+            bucket,
+            reason: r.reason,
+            ...(r.count !== undefined ? { count: r.count } : {}),
+            ...(r.cap !== undefined ? { cap: r.cap } : {}),
+            ...(r.folded === true ? { folded: true } : {}),
+        });
+    }
+    return Object.freeze({ bucket, reason: r.reason, ...(r.index !== undefined ? { index: r.index } : {}), ...(r.folded === true ? { folded: true } : {}) });
+}
+export function fieldLimitRefusalFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
             return null;
@@ -306,71 +287,165 @@ export function settingsPermissionBucketRefusalFromError(err) {
             return null;
         }
         const field = readErrorString(err, 'field');
-        const bucket = field !== undefined && Object.hasOwn(BUCKET_OF_FIELD, field) ? BUCKET_OF_FIELD[field] : undefined;
-        if (bucket === undefined)
+        if (field === undefined || field.length === 0)
             return null;
         const reason = readErrorString(err, 'reason');
-        if (reason !== 'over_cap' && reason !== 'bad_entry')
+        if (reason !== 'over_cap' && reason !== 'too_long' && reason !== 'bad_entry')
             return null;
         const folded = outer === RESUME_POLICY_FOLD_CODE;
-        if (reason === 'over_cap') {
-            const count = nonNegInt(readErrorNumber(err, 'count'));
-            const cap = posInt(readErrorNumber(err, 'cap'));
-            return Object.freeze({
+        if (reason === 'bad_entry') {
+            const index = nonNegInt(readErrorNumber(err, 'index'));
+            return Object.freeze({ field, reason, ...(index !== undefined ? { index } : {}), ...(folded ? { folded: true } : {}) });
+        }
+        const count = nonNegInt(readErrorNumber(err, 'count'));
+        const cap = posInt(readErrorNumber(err, 'cap'));
+        return Object.freeze({
+            field,
+            reason,
+            ...(count !== undefined ? { count } : {}),
+            ...(cap !== undefined ? { cap } : {}),
+            ...(folded ? { folded: true } : {}),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+const FIELD_LIMIT_REFUSAL_UNKNOWN = 'The engine refused this request: a list in it has too many entries, or a text in it is too long · Nothing was trimmed or dropped — shorten it, then send the request again';
+const FIELD_LIMIT_FIELD_MAX = 120;
+export function fieldLimitRefusalContent(detail, lang) {
+    try {
+        if (typeof detail !== 'object' || detail === null)
+            return FIELD_LIMIT_REFUSAL_UNKNOWN;
+        const field = detail.field;
+        const reason = detail.reason;
+        if (typeof field !== 'string' || field.length === 0)
+            return FIELD_LIMIT_REFUSAL_UNKNOWN;
+        const folded = detail.folded === true;
+        const bucket = Object.hasOwn(BUCKET_OF_FIELD, field) ? BUCKET_OF_FIELD[field] : undefined;
+        if (bucket !== undefined && (reason === 'over_cap' || reason === 'bad_entry')) {
+            return settingsPermissionBucketRefusalContent({
                 bucket,
                 reason,
-                ...(count !== undefined ? { count } : {}),
-                ...(cap !== undefined ? { cap } : {}),
+                ...(reason === 'over_cap' && nonNegInt(detail.count) !== undefined ? { count: detail.count } : {}),
+                ...(reason === 'over_cap' && posInt(detail.cap) !== undefined ? { cap: detail.cap } : {}),
+                ...(reason === 'bad_entry' && nonNegInt(detail.index) !== undefined ? { index: detail.index } : {}),
                 ...(folded ? { folded: true } : {}),
-            });
+            }, lang);
         }
-        const index = nonNegInt(readErrorNumber(err, 'index'));
-        return Object.freeze({ bucket, reason, ...(index !== undefined ? { index } : {}), ...(folded ? { folded: true } : {}) });
+        if (reason !== 'over_cap' && reason !== 'too_long' && reason !== 'bad_entry')
+            return FIELD_LIMIT_REFUSAL_UNKNOWN;
+        const where = `the request field ${capForDisplay(field, FIELD_LIMIT_FIELD_MAX)}`;
+        const subject = folded ? 'The engine refused to continue this parked work: in the request stored for it,' : 'The engine refused this request:';
+        let what;
+        if (reason === 'bad_entry') {
+            const index = nonNegInt(detail.index);
+            what = index !== undefined ? `entry ${index + 1} of ${where} is not valid` : `${where} is not valid`;
+        }
+        else {
+            const count = nonNegInt(detail.count);
+            const cap = posInt(detail.cap);
+            const unit = reason === 'over_cap' ? 'entries' : 'characters';
+            what =
+                count !== undefined && cap !== undefined
+                    ? count > cap
+                        ? `${where} has ${count} ${unit}, ${count - cap} more than the ${cap} the engine accepts`
+                        : `${where} has ${count} ${unit}, and the engine accepts at most ${cap}`
+                    : reason === 'over_cap'
+                        ? `${where} has more entries than the engine accepts`
+                        : `${where} is longer than the engine accepts`;
+        }
+        const fix = reason === 'bad_entry' ? 'fix or remove that entry' : reason === 'over_cap' ? 'remove some entries or merge them' : 'shorten it';
+        const next = folded
+            ? `It cannot continue as stored, and the engine refuses rather than silently trimming — ${fix}, then submit the work again as a new request`
+            : `Nothing was trimmed or dropped, because the engine refuses rather than silently trimming — ${fix}, then send the request again`;
+        return `${subject} ${what} · ${next}`;
     }
     catch {
-        return null;
+        return FIELD_LIMIT_REFUSAL_UNKNOWN;
     }
 }
-const BUCKET_REFUSAL_UNKNOWN = "The engine refused the permission rules in this request's settings as too many or malformed · Nothing was trimmed or dropped — fix the rule lists, then send the request again";
-export function settingsPermissionBucketRefusalContent(detail) {
+const BUCKET_REFUSAL_UNKNOWN = 'notice.wireRefusal.bucket.unknown';
+export function settingsPermissionBucketRefusalContent(detail, lang) {
     try {
         if (typeof detail !== 'object' || detail === null)
-            return BUCKET_REFUSAL_UNKNOWN;
+            return renderMessage(msg(BUCKET_REFUSAL_UNKNOWN), lang);
         const bucket = detail.bucket;
         const reason = detail.reason;
         if (bucket !== 'allow' && bucket !== 'deny' && bucket !== 'ask')
-            return BUCKET_REFUSAL_UNKNOWN;
+            return renderMessage(msg(BUCKET_REFUSAL_UNKNOWN), lang);
         if (reason !== 'over_cap' && reason !== 'bad_entry')
-            return BUCKET_REFUSAL_UNKNOWN;
+            return renderMessage(msg(BUCKET_REFUSAL_UNKNOWN), lang);
         const folded = detail.folded === true;
-        const subject = folded ? 'The engine refused to continue this parked work: in the request stored for it,' : 'The engine refused this request:';
-        const list = `the ${bucket} rule list in the permission settings (permissions.${bucket})`;
+        const subject = renderMessage(folded ? msg('notice.wireRefusal.bucket.subject.stored') : msg('notice.wireRefusal.bucket.subject.fresh'), lang);
+        const list = msg('notice.wireRefusal.bucket.list', { bucket });
         let what;
         let fix;
         if (reason === 'over_cap') {
             const count = nonNegInt(detail.count);
             const cap = posInt(detail.cap);
-            what =
-                count !== undefined && cap !== undefined
-                    ? count > cap
-                        ? `${list} has ${count} entries, ${count - cap} more than the ${cap} the engine accepts`
-                        : `${list} has ${count} entries, and the engine accepts at most ${cap}`
-                    : `${list} has more entries than the engine accepts`;
-            fix = 'merge rules into broader patterns or remove some';
+            what = renderMessage(count !== undefined && cap !== undefined
+                ? count > cap
+                    ? msg('notice.wireRefusal.bucket.what.overCap.more', { list, count, excess: count - cap, cap })
+                    : msg('notice.wireRefusal.bucket.what.overCap.atMost', { list, count, cap })
+                : msg('notice.wireRefusal.bucket.what.overCap.unknown', { list }), lang);
+            fix = renderMessage(msg('notice.wireRefusal.bucket.fix.merge'), lang);
         }
         else {
             const index = nonNegInt(detail.index);
-            what = index !== undefined ? `entry ${index + 1} of ${list} is empty or not text` : `${list} is not a list of rules`;
-            fix = index !== undefined ? 'fix or remove that entry, so every entry is a non-empty rule' : 'make it a list of non-empty rules';
+            what = renderMessage(index !== undefined ? msg('notice.wireRefusal.bucket.what.badEntry.at', { position: index + 1, list }) : msg('notice.wireRefusal.bucket.what.badEntry.notList', { list }), lang);
+            fix = renderMessage(msg(index !== undefined ? 'notice.wireRefusal.bucket.fix.entry' : 'notice.wireRefusal.bucket.fix.list'), lang);
         }
-        const next = folded
-            ? `It cannot continue as stored, and the engine refuses the list rather than silently losing rules — ${fix}, then submit the work again as a new request`
-            : `Nothing was trimmed or dropped, because the engine refuses the list rather than silently losing rules — ${fix}, then send the request again`;
+        const next = renderMessage(msg(folded ? 'notice.wireRefusal.bucket.next.stored' : 'notice.wireRefusal.bucket.next.fresh', { fix }), lang);
         return `${subject} ${what} · ${next}`;
     }
     catch {
-        return BUCKET_REFUSAL_UNKNOWN;
+        return renderMessage(msg(BUCKET_REFUSAL_UNKNOWN), lang);
+    }
+}
+const PAYLOAD_TOO_LARGE = 'request.payload_too_large';
+const BLOB_TOO_LARGE_FOR_SQL = 'blob_too_large_for_sql';
+export function admissionWallRefusalFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const code = readThrownSlot(err, 'errorCode', 'data');
+        if (code !== PAYLOAD_TOO_LARGE && code !== BLOB_TOO_LARGE_FOR_SQL)
+            return null;
+        const wallSource = readErrorString(err, 'wallSource');
+        if (wallSource === 'reported' || wallSource === 'assumed')
+            return Object.freeze({ code, wallSource });
+        if (wallSource === 'operator' && code === BLOB_TOO_LARGE_FOR_SQL)
+            return Object.freeze({ code, wallSource });
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function admissionWallRefusalContent(detail) {
+    let code;
+    let source;
+    try {
+        code = detail.code;
+        source = detail.wallSource;
+    }
+    catch {
+        code = source = undefined;
+    }
+    const subject = code === BLOB_TOO_LARGE_FOR_SQL ? 'This snapshot file' : 'This request';
+    if (source === 'assumed') {
+        return (`${subject} was refused at the most conservative size limit, because this deployment has not read its database’s actual limit yet · ` +
+            'Nothing was stored · Try again shortly; if it keeps happening, ask whoever operates the engine to let the service read the database’s size limit');
+    }
+    if (source === 'operator' && code === BLOB_TOO_LARGE_FOR_SQL) {
+        return ('This snapshot file is larger than the cap whoever operates the engine set for snapshots stored in the database · Nothing was stored · ' +
+            'Ask them to configure object storage for large snapshots, or to raise that cap');
     }
+    return code === BLOB_TOO_LARGE_FOR_SQL
+        ? 'This snapshot file is larger than this deployment’s database can store in one piece · Nothing was stored · Ask whoever operates the engine to configure object storage for large snapshots, or to raise the database’s limit'
+        : 'This request is larger than this deployment’s database accepts for one submitted task · Nothing was stored · ' +
+            'Shrink the inline images or attachments, or ask whoever operates the engine to raise the database’s limit (the engine’s own message names which one), then send it again';
 }
 export function toolDeclarationRefusalFromError(err) {
     try {
@@ -385,10 +460,9 @@ export function toolDeclarationRefusalFromError(err) {
         return null;
     }
 }
-const TOOL_DECLARATION_REFUSAL = "The engine refused to start this run because of a tool this request declares; the engine's own message says which tool and what is wrong with it · " +
-    'This is a problem with the request itself, not a temporary outage — sending the same request again is refused the same way; fix or remove that tool declaration, then send it';
-export function toolDeclarationRefusalContent(_detail) {
-    return TOOL_DECLARATION_REFUSAL;
+const TOOL_DECLARATION_REFUSAL = 'notice.wireRefusal.toolDeclaration';
+export function toolDeclarationRefusalContent(_detail, lang) {
+    return renderMessage(msg(TOOL_DECLARATION_REFUSAL), lang);
 }
 const BODY_SHAPE = 'request.body_shape';
 const SETTINGS_KEY_PREFIX = 'settings.';
@@ -526,7 +600,7 @@ function readProp(o, key) {
 }
 export function hostPostureRefusalFromError(err, sentRequest) {
     try {
-        if (readProp(err, 'errorCode') !== HOST_POSTURE_REFUSED)
+        if (readThrownSlot(err, 'errorCode', 'data') !== HOST_POSTURE_REFUSED)
             return null;
         const askedWholeEnvironment = readProp(sentRequest, 'inheritEnv') === 'all';
         const askedOpenWriteFace = readProp(sentRequest, 'permissionMode') === BYPASS_PERMISSIONS ||
@@ -541,33 +615,54 @@ export function hostPostureRefusalFromError(err, sentRequest) {
         return null;
     }
 }
-const HOST_POSTURE_NOT_LOCAL = 'This is not a problem with your local settings and not something this client can grant — whoever runs this engine decides it';
-const HOST_POSTURE_WHOLE_ENV = "The engine refused this request before anything ran: this deployment serves more than one user, so a request may not hand the shell this machine's whole environment · " +
-    `${HOST_POSTURE_NOT_LOCAL}; send it again without the whole-environment setting (or with the default), and the shell gets the default environment, with credential-like variables removed`;
-const HOST_POSTURE_WRITE_FACE = 'The engine refused this request before anything ran: this deployment does not let a request lift the write boundary with bypassPermissions · ' +
-    `${HOST_POSTURE_NOT_LOCAL}; send it again with another permission mode`;
-const HOST_POSTURE_BOTH = "The engine refused this request before anything ran: the request asked both for the shell to inherit this machine's whole environment and for bypassPermissions, and this deployment refused at least one of them; the refusal does not say which · " +
-    `${HOST_POSTURE_NOT_LOCAL}; send it again without one or both (the whole-environment setting is honored only on a single-user deployment)`;
-const HOST_POSTURE_UNATTRIBUTED = "The engine refused this request before anything ran: this deployment does not accept a setting in it that only a single-user deployment may use; the engine's own message names it · " +
-    `${HOST_POSTURE_NOT_LOCAL}; send it again without that setting`;
-export function hostPostureRefusalContent(detail) {
+const HOST_POSTURE_NOT_LOCAL = 'notice.wireRefusal.hostPosture.notLocal';
+const HOST_POSTURE_WHOLE_ENV = 'notice.wireRefusal.hostPosture.wholeEnv';
+const HOST_POSTURE_WRITE_FACE = 'notice.wireRefusal.hostPosture.writeFace';
+const HOST_POSTURE_BOTH = 'notice.wireRefusal.hostPosture.both';
+const HOST_POSTURE_UNATTRIBUTED = 'notice.wireRefusal.hostPosture.unattributed';
+export function hostPostureRefusalContent(detail, lang) {
+    const say = (key) => renderMessage(msg(key, { notLocal: msg(HOST_POSTURE_NOT_LOCAL) }), lang);
     try {
         const env = readProp(detail, 'askedWholeEnvironment') === true;
         const write = readProp(detail, 'askedOpenWriteFace') === true;
         if (env && write)
-            return HOST_POSTURE_BOTH;
+            return say(HOST_POSTURE_BOTH);
         if (env)
-            return HOST_POSTURE_WHOLE_ENV;
+            return say(HOST_POSTURE_WHOLE_ENV);
         if (write)
-            return HOST_POSTURE_WRITE_FACE;
-        return HOST_POSTURE_UNATTRIBUTED;
+            return say(HOST_POSTURE_WRITE_FACE);
+        return say(HOST_POSTURE_UNATTRIBUTED);
     }
     catch {
-        return HOST_POSTURE_UNATTRIBUTED;
+        return say(HOST_POSTURE_UNATTRIBUTED);
     }
 }
 const HOOK_MATCHER_REFUSAL_FIELD = 'settings.hooks';
 export function hookMatcherRefusalFromError(err) {
+    return settingsHooksRefusalFromError(err)?.matcher;
+}
+function hooksRefusalPathOf(detail) {
+    try {
+        const raw = readOwnDataValue(detail, 'path');
+        if (!Array.isArray(raw))
+            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 Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function settingsHooksRefusalFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
             return undefined;
@@ -578,31 +673,43 @@ export function hookMatcherRefusalFromError(err) {
         const detail = readErrorRecord(err, 'detail');
         if (detail === undefined)
             return undefined;
-        const event = readOwnNonEmptyString(detail, 'event');
-        if (event === undefined)
-            return undefined;
         const reasonRaw = readOwnDataValue(detail, 'reason');
+        const path = hooksRefusalPathOf(detail);
+        const withPath = (o) => Object.freeze({ ...o, ...(path !== undefined ? { path } : {}) });
+        const family = (reason, rest = {}) => Object.freeze({ reason, ...(path !== undefined ? { path } : {}), ...rest });
+        const event = readOwnNonEmptyString(detail, 'event');
         if (reasonRaw === undefined || reasonRaw === 'dead_alias') {
             const alias = readOwnNonEmptyString(detail, 'alias');
             const canonical = readOwnNonEmptyString(detail, 'canonical');
-            if (alias === undefined || canonical === undefined)
+            const matcher = event !== undefined && alias !== undefined && canonical !== undefined ? withPath({ reason: 'alias_without_canonical', event, alias, canonical }) : undefined;
+            if (reasonRaw === undefined && matcher === undefined)
                 return undefined;
-            return Object.freeze({ reason: 'alias_without_canonical', event, alias, canonical });
+            return family('dead_alias', matcher !== undefined ? { matcher } : {});
         }
-        if (reasonRaw !== 'invalid_regex' && reasonRaw !== 'over_budget')
-            return undefined;
-        const groupIndex = readOwnDataValue(detail, 'groupIndex');
-        if (typeof groupIndex !== 'number' || !Number.isInteger(groupIndex) || groupIndex < 0)
+        if (typeof reasonRaw !== 'string' || reasonRaw.length === 0)
             return undefined;
-        if (reasonRaw === 'invalid_regex')
-            return Object.freeze({ reason: 'invalid_regex', event, groupIndex });
-        const budget = readOwnDataValue(detail, 'budgetMs');
-        return Object.freeze({
-            reason: 'over_budget',
-            event,
-            groupIndex,
-            ...(typeof budget === 'number' && Number.isFinite(budget) && budget > 0 ? { budgetMs: budget } : {}),
-        });
+        if (reasonRaw === 'invalid_regex' || reasonRaw === 'over_budget' || reasonRaw === 'budget_exceeded') {
+            const groupIndex = readOwnDataValue(detail, 'groupIndex');
+            const okIndex = typeof groupIndex === 'number' && Number.isInteger(groupIndex) && groupIndex >= 0;
+            let matcher;
+            if (event !== undefined && okIndex) {
+                if (reasonRaw === 'invalid_regex')
+                    matcher = withPath({ reason: 'invalid_regex', event, groupIndex });
+                else {
+                    const key = reasonRaw === 'over_budget' ? 'budgetMs' : 'totalMs';
+                    const ms = readOwnDataValue(detail, key);
+                    const msBit = typeof ms === 'number' && Number.isFinite(ms) && ms > 0 ? { [key]: ms } : {};
+                    matcher = reasonRaw === 'over_budget' ? withPath({ reason: 'over_budget', event, groupIndex, ...msBit }) : withPath({ reason: 'budget_exceeded', event, groupIndex, ...msBit });
+                }
+            }
+            return family(reasonRaw, matcher !== undefined ? { matcher } : {});
+        }
+        if (reasonRaw === 'over_cap' || reasonRaw === 'too_long') {
+            const count = nonNegInt(readOwnDataValue(detail, 'count'));
+            const cap = posInt(readOwnDataValue(detail, 'cap'));
+            return family(reasonRaw, { ...(count !== undefined ? { count } : {}), ...(cap !== undefined ? { cap } : {}) });
+        }
+        return family(reasonRaw);
     }
     catch {
         return undefined;
@@ -611,7 +718,59 @@ export function hookMatcherRefusalFromError(err) {
 export function autonomyLaneRefusalFromError(err) {
     return effectiveWireErrorCode(err) === REQUEST_AUTONOMY_LANE_REFUSED ? { code: REQUEST_AUTONOMY_LANE_REFUSED } : null;
 }
-export function autonomyLaneRefusalContent() {
-    return ('The engine did not start this leader run: this deployment runs in plan-only autonomy, and a leader run has no way to have its plan reviewed, ' +
-        'so nothing was started · Submit the work as a regular run instead, or ask whoever operates the engine to change its autonomy setting');
+export function autonomyLaneRefusalContent(lang) {
+    return renderMessage(msg('notice.wireRefusal.autonomyLane'), lang);
+}
+export function userAttachmentRefusalFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        let facts;
+        const kind = readOwnDataValue(err, 'kind');
+        const plane = readOwnDataValue(err, 'plane');
+        if (kind === 'failed' && (plane === 'cause' || plane === 'flat')) {
+            if (readOwnDataValue(err, 'code') !== USER_ATTACHMENT_INVALID_ERROR_CODE)
+                return null;
+            const cause = readOwnDataValue(err, 'detail');
+            const inner = typeof cause === 'object' && cause !== null && readOwnDataValue(cause, 'kind') === 'coded' ? readOwnDataValue(cause, 'detail') : undefined;
+            facts = typeof inner === 'object' && inner !== null && !Array.isArray(inner) ? inner : undefined;
+        }
+        else {
+            if (effectiveWireErrorCode(err) !== USER_ATTACHMENT_INVALID_ERROR_CODE)
+                return null;
+            facts = readErrorRecord(err, 'detail');
+        }
+        let index;
+        let path;
+        try {
+            index = facts === undefined ? undefined : readOwnDataValue(facts, 'index');
+        }
+        catch {
+            index = undefined;
+        }
+        try {
+            path = facts === undefined ? undefined : readOwnDataValue(facts, 'path');
+        }
+        catch {
+            path = undefined;
+        }
+        return {
+            code: USER_ATTACHMENT_INVALID_ERROR_CODE,
+            retryable: false,
+            ...(typeof index === 'number' && Number.isSafeInteger(index) && index >= 0 ? { index } : {}),
+            ...(typeof path === 'string' && path.length > 0 ? { path } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function userAttachmentRefusalContent(detail) {
+    return prepareRefusalNoteOf(USER_ATTACHMENT_INVALID_ERROR_CODE, detail);
+}
+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);
 }