@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/ownKey.js

@@ -189,3 +189,78 @@ export function mcpSectionDroppedNamedRowsOf(rows, name) {
         return 0;
     }
 }
+export function promptManifestSectionViewOf(row) {
+    const o = row;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const id = str(o.id);
+    const chars = typeof o.chars === 'number' && Number.isFinite(o.chars) && o.chars >= 0 ? o.chars : undefined;
+    if (id === undefined || chars === undefined)
+        return undefined;
+    const band = str(o.band);
+    const locale = str(o.locale);
+    const variant = str(o.variant);
+    const contentHash = band !== undefined ? str(o.contentHash) : undefined;
+    const slot = str(o.slot);
+    return {
+        id,
+        chars,
+        ...(band !== undefined ? { band } : {}),
+        ...(locale !== undefined ? { locale } : {}),
+        ...(variant !== undefined ? { variant } : {}),
+        ...(contentHash !== undefined ? { contentHash } : {}),
+        ...(slot !== undefined ? { slot } : {}),
+    };
+}
+export function promptManifestIdentityOfFrame(frame) {
+    let raw;
+    try {
+        raw = frame.identity;
+    }
+    catch {
+        return undefined;
+    }
+    return promptManifestIdentityOf(typeof raw === 'object' && raw !== null ? raw : undefined);
+}
+export function promptManifestIdentityOf(raw) {
+    try {
+        const plain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+        const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+        if (!plain(raw))
+            return undefined;
+        const artifact = str(raw.artifact);
+        const activatedBy = str(raw.activatedBy);
+        const epochRaw = raw.epoch;
+        const epoch = typeof epochRaw === 'number' && Number.isInteger(epochRaw) && epochRaw >= 0 ? epochRaw : undefined;
+        const layersRaw = raw.layers;
+        if (artifact === undefined || activatedBy === undefined || epoch === undefined || !plain(layersRaw))
+            return undefined;
+        const catalog = str(layersRaw.catalog);
+        const binding = str(layersRaw.binding);
+        if (catalog === undefined || binding === undefined)
+            return undefined;
+        const optional = {};
+        for (const k of ['center', 'deploy', 'task']) {
+            const v = layersRaw[k];
+            if (v === undefined)
+                continue;
+            const t = str(v);
+            if (t === undefined)
+                return undefined;
+            optional[k] = t;
+        }
+        const renderersRaw = layersRaw.renderers;
+        if (!plain(renderersRaw))
+            return undefined;
+        const entries = [];
+        for (const [k, v] of Object.entries(renderersRaw)) {
+            if (typeof v !== 'number' || !Number.isFinite(v))
+                return undefined;
+            entries.push([k, v]);
+        }
+        const renderers = Object.fromEntries(entries);
+        return { artifact, layers: { catalog, renderers, ...optional, binding }, epoch, activatedBy };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/panelReduce.d.ts

@@ -116,6 +116,11 @@ export declare function reducePanelFrame(state: PanelReduceState, frame: PanelFr
 };
 export declare function panelRowSnapshot(state: PanelReduceState): PanelDelta[];
 export declare function panelResolveTaskId(state: PanelReduceState, wireTaskId: string): EnginePanelTaskIdentity;
+export interface PanelSubagentIdentity {
+    readonly key: string;
+    readonly ids: readonly string[];
+}
+export declare function panelSubagentOf(state: PanelReduceState, id: string): PanelSubagentIdentity | undefined;
 export declare function panelIsResident(state: PanelReduceState, taskId: string): boolean;
 export declare function panelAnchorOf(state: PanelReduceState, taskId: string): string | undefined;
 export declare function panelPresenceSize(state: PanelReduceState, sessionKey: string): number;

package/dist/panelReduce.js

@@ -1,6 +1,6 @@
 import { rowIdTail } from './workflow.js';
 import { isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess } from './terminalStatuses.js';
-import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, mergeCycle, } from './cycleOrder.js';
+import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, cycleSeqValue, mergeCycle, } from './cycleOrder.js';
 export function isStaleEngineAgentPanelEnd(end, current) {
     return cycleOrder(end, current) === 'before';
 }
@@ -575,10 +575,26 @@ function fullUsage(key, row) {
         return undefined;
     return usageDelta(key, { ...(row.totalTokens !== undefined ? { totalTokens: row.totalTokens } : {}), ...(row.toolUses !== undefined ? { toolUses: row.toolUses } : {}), ...(fin !== undefined ? { final: fin } : {}) });
 }
+function ownDataOf(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function publisherFinality(f) {
+    return { ...(ownDataOf(f, 'totalTokens') === true ? { totalTokens: true } : {}), ...(ownDataOf(f, 'toolUses') === true ? { toolUses: true } : {}) };
+}
 function fleetCarrier(ev) {
-    const f = ev.final;
-    const final = { ...(f?.totalTokens === true ? { totalTokens: true } : {}), ...(f?.toolUses === true ? { toolUses: true } : {}) };
-    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final };
+    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final: publisherFinality(ownDataOf(ev, 'final')) };
+}
+function tickCycleOf(ev) {
+    const c = cycleSeqValue(ownDataOf(ev, 'cycleSeq'));
+    return c === undefined ? undefined : { cycleSeq: c };
 }
 function finalityOf(tokens, toolUses) {
     if (tokens === undefined && toolUses === undefined)
@@ -638,17 +654,20 @@ function announce(d, rid) {
     if (row.phase === 'ended')
         mintTerminal(d, key, row.isError === true, row.report, 'end');
 }
-function foldTick(d, rid, ev, cardBound) {
+function foldTick(d, rid, ev, cardBound, final) {
     const r = d.rec(rid);
     if (r === undefined)
         return;
     const row = r.row;
     const gate = cardBound ? { gateBound: true } : {};
     const wireId = ev.wireTaskId ?? ev.taskId;
-    const attributable = !hasCycleSeq(r.cycle) && (r.currentRun === undefined || r.currentRun === wireId);
+    const tickCycle = tickCycleOf(ev);
+    const attributable = hasCycleSeq(r.cycle)
+        ? tickCycle !== undefined && cycleOrder(tickCycle, r.cycle) === 'same'
+        : r.currentRun === undefined || r.currentRun === wireId;
     if (!attributable)
         d.counts.unattributedTicks++;
-    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses } : {};
+    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final } : {};
     if (row === undefined || !row.announced) {
         const base = row !== undefined
             ? { ...row, ...gate, tickSeen: true, fields: { ...row.fields, ...tickFields(ev) } }
@@ -789,28 +808,37 @@ function foldAbsence(d, rid, a) {
     d.deltas.push({ op: 'upsert', canonicalId: keyOf(r), fields: { absence } });
     d.put(rid, { row: { ...row, fields: { ...row.fields, absence } } });
 }
-function stripCardBound(ev) {
-    const { cardBound: _cardBound, ...rest } = ev;
-    void _cardBound;
-    return rest;
+function tickFactBase(ev) {
+    const out = {};
+    for (const k of Reflect.ownKeys(ev)) {
+        if (typeof k !== 'string' || k === 'cardBound' || k === 'final' || k === 'cycleSeq')
+            continue;
+        if (!Object.prototype.propertyIsEnumerable.call(ev, k))
+            continue;
+        out[k] = Reflect.get(ev, k);
+    }
+    return out;
 }
 function emitTick(d, ev) {
     const found = d.find(ev.taskId);
     const fr = found !== undefined ? d.rec(found) : undefined;
     if (fr !== undefined && formerGeneration(fr, ev.taskId))
         return;
+    const tickCycle = tickCycleOf(ev);
+    if (fr !== undefined && tickCycle !== undefined && cycleOrder(tickCycle, genOf(fr)) === 'before')
+        return;
     const rid = found ?? d.create({ id: ev.taskId });
     d.records.touch(rid);
     const r = d.rec(rid);
     if (r === undefined)
         return;
     const key = keyOf(r);
-    const plain = stripCardBound(ev);
+    const plain = { ...tickFactBase(ev), ...(tickCycle !== undefined ? { cycleSeq: tickCycle.cycleSeq } : {}) };
     const fact = key === ev.taskId
         ? { ...plain, taskIdOrigin: 'wire' }
         : { ...plain, taskId: key, wireTaskId: ev.taskId, taskIdOrigin: key === r.tail ? 'fleet-row' : 'wire' };
     d.facts.push({ ch: 'event', ev: fact });
-    foldTick(d, rid, fact, ev.cardBound === true);
+    foldTick(d, rid, fact, ev.cardBound === true, publisherFinality(ownDataOf(ev, 'final')));
 }
 function flushHeld(d, wireTaskId) {
     const held = d.pending.get(wireTaskId);
@@ -1278,6 +1306,10 @@ export function panelResolveTaskId(state, wireTaskId) {
         return { taskId: wireTaskId, origin: 'wire' };
     return { taskId: r.tail, origin: 'fleet-row', ...cycleOf(bindingOf(r, wireTaskId)?.gen) };
 }
+export function panelSubagentOf(state, id) {
+    const r = recordOfId(state, id);
+    return r === undefined ? undefined : { key: keyOf(r), ids: idsOf(r) };
+}
 export function panelIsResident(state, taskId) {
     return recordOfId(state, taskId)?.resident === true;
 }

package/dist/panelStateHolder.d.ts

@@ -1,5 +1,6 @@
 import { type PanelDelta, type PanelFact, type PanelFrame, type PanelReduceState } from './panelReduce.js';
 export declare function panelStateNow(): PanelReduceState;
+export declare function panelSubagentIdsNow(id: string): readonly string[] | undefined;
 export declare function stepEnginePanel(frame: PanelFrame): void;
 export declare function replaceEnginePanelState(fn: (s: PanelReduceState) => PanelReduceState): void;
 export declare function clearEnginePanelIdentity(): void;

package/dist/panelStateHolder.js

@@ -1,9 +1,17 @@
-import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, stepPanelFrame, } from './panelReduce.js';
+import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, panelSubagentOf, stepPanelFrame, } from './panelReduce.js';
+import { bindSubagentIdentityReader } from './subagentContentStore.js';
 let state = createPanelReduceState();
 export function panelStateNow() {
     return state;
 }
+export function panelSubagentIdsNow(id) {
+    return panelSubagentOf(state, id)?.ids;
+}
+function bindIdentityReader() {
+    bindSubagentIdentityReader(panelSubagentIdsNow);
+}
 export function stepEnginePanel(frame) {
+    bindIdentityReader();
     const r = stepPanelFrame(state, frame);
     state = r.state;
     if (rowListener !== null)
@@ -18,6 +26,7 @@ export function stepEnginePanel(frame) {
     }
 }
 export function replaceEnginePanelState(fn) {
+    bindIdentityReader();
     state = fn(state);
 }
 export function clearEnginePanelIdentity() {

package/dist/permissionRuleIssue.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const PERMISSION_RULE_ISSUE_CODES: readonly string[];
 export declare const RETIRED_PERMISSION_RULE_ISSUE_CODES: readonly string[];
-export declare function permissionRuleIssueDetail(code: unknown, message: unknown, rule?: string): string;
+export declare function permissionRuleIssueDetail(code: unknown, message: unknown, rule?: string, lang?: UiLanguage): string;

package/dist/permissionRuleIssue.js

@@ -1,4 +1,5 @@
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'invalid.empty_tool',
     'invalid.paren',
@@ -20,25 +21,25 @@ export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
 export const RETIRED_PERMISSION_RULE_ISSUE_CODES = Object.freeze(['unsupported.unknown_param']);
 const ISSUE_MESSAGE_MAX = 200;
 const ISSUE_SENTENCES = Object.freeze({
-    'invalid.empty_tool': 'this rule is invalid: it names no tool',
-    'invalid.paren': 'this rule is invalid: its parentheses do not parse (escape a literal one as \\( or \\))',
-    'invalid.tool_name': "this rule is invalid: its tool name is not spelled as a tool name (blanks around the rule, an invisible or disallowed character in the name or before the parenthesis, a leading '-', or the wildcard '*', which names no tool), so it would reach no tool or the wrong one",
-    'invalid.param_split': 'this rule is invalid: its parentheses do not hold a parameter rule written name:pattern',
-    'invalid.primary_field': "this rule is invalid: it patterns the tool's primary field, which matches the whole trimmed string rather than a prefix",
-    'invalid.cap_exceeded': 'this rule set is invalid: it is over one of the deployment caps (rule count, rule length, pattern length, or star count); this client cannot tell which from the code alone',
-    'invalid.behavior': 'this rule is invalid: its behavior is neither deny nor ask, so it would never fire',
-    'invalid.command_rule': 'this rule is invalid: the command pattern was rejected by the command-rule validator',
-    'invalid.entry_type': 'this allow list is invalid: it must be a list of rule strings, and it or one of its entries is not a string',
-    'unsupported.allow': 'an allow rule is not supported in a rule set that only says deny or ask — a standing approval belongs on the allow list instead',
-    'unsupported.param_unknown': 'this parameter rule is not supported: the tool carries no such parameter, so it could never match',
-    'unsupported.param_non_scalar': 'this parameter rule is not supported: that parameter holds an object or an array, so it could never match',
-    'unsupported.tool_unknown': "this rule is not supported on this leg: the resolver it supplied does not know the tool, so the rule's face cannot be checked",
-    'unsupported.path_base': 'this path rule is not supported as spelled: the base it is relative to is missing or is not a usable absolute path, so it would reach nothing and is refused rather than compiled',
-    'unsupported.mcp_paren': 'a parenthesised parameter rule is not supported on an MCP tool name',
-    'unsupported.covering_paren': 'a parenthesised parameter rule is not supported on a covering protocol name — the parameter grammar is keyed by an exact tool name, so no mounted tool could ever bear it',
+    'invalid.empty_tool': 'rules.issue.emptyTool',
+    'invalid.paren': 'rules.issue.paren',
+    'invalid.tool_name': 'rules.issue.toolName',
+    'invalid.param_split': 'rules.issue.paramSplit',
+    'invalid.primary_field': 'rules.issue.primaryField',
+    'invalid.cap_exceeded': 'rules.issue.capExceeded',
+    'invalid.behavior': 'rules.issue.behavior',
+    'invalid.command_rule': 'rules.issue.commandRule',
+    'invalid.entry_type': 'rules.issue.entryType',
+    'unsupported.allow': 'rules.issue.allowRule',
+    'unsupported.param_unknown': 'rules.issue.paramUnknown',
+    'unsupported.param_non_scalar': 'rules.issue.paramNonScalar',
+    'unsupported.tool_unknown': 'rules.issue.toolUnknown',
+    'unsupported.path_base': 'rules.issue.pathBase',
+    'unsupported.mcp_paren': 'rules.issue.mcpParen',
+    'unsupported.covering_paren': 'rules.issue.coveringParen',
 });
-const PARAM_SPLIT_WITH_COLON = 'this rule is invalid: a parameter rule is written name:pattern, and the name before the colon or the pattern after it is empty';
-const PARAM_SPLIT_NO_COLON = 'this rule is invalid: there is no colon inside the parentheses, so this is not a parameter rule (a parameter rule is written name:pattern)';
+const PARAM_SPLIT_WITH_COLON = 'rules.issue.paramSplitWithColon';
+const PARAM_SPLIT_NO_COLON = 'rules.issue.paramSplitNoColon';
 function colonInsideParens(rule) {
     if (typeof rule !== 'string')
         return undefined;
@@ -53,7 +54,7 @@ function colonInsideParens(rule) {
     }
     return undefined;
 }
-export function permissionRuleIssueDetail(code, message, rule) {
+export function permissionRuleIssueDetail(code, message, rule, lang) {
     const colon = code === 'invalid.param_split' ? colonInsideParens(rule) : undefined;
     const known = colon !== undefined
         ? colon ? PARAM_SPLIT_WITH_COLON : PARAM_SPLIT_NO_COLON
@@ -63,7 +64,7 @@ export function permissionRuleIssueDetail(code, message, rule) {
         : '';
     const codeWord = typeof code === 'string' && code.length > 0 ? escapeDisplayControlChars(code) : '(no code)';
     const head = known !== undefined
-        ? known
-        : `this rule was refused with ${codeWord}, a code newer than this client`;
+        ? renderMessage(msg(known), lang)
+        : renderMessage(msg('rules.issue.newerCode', { code: codeWord }), lang);
     return text.length > 0 ? `${head} — ${text}` : head;
 }

package/dist/pluginHooksWire.js

@@ -51,8 +51,8 @@ export function hooksWirePlanShapeOf(v) {
         return Array.isArray(o.verdicts) &&
             Array.isArray(o.excluded) &&
             Array.isArray(o.settingsDropped) &&
-            arrayOrAbsent('settingsVerdicts') &&
-            arrayOrAbsent('settingsExcluded') &&
+            Array.isArray(o.settingsVerdicts) &&
+            Array.isArray(o.settingsExcluded) &&
             arrayOrAbsent('settingsSalvage') &&
             arrayOrAbsent('moduleVerdicts') &&
             arrayOrAbsent('sessionVerdicts') &&
@@ -70,7 +70,7 @@ export function hooksWirePlanShapeOf(v) {
     }
 }
 const PLAN_KEYS = ['engine', 'pluginReader', 'verdicts', 'excluded', 'settingsDropped', 'settingsVerdicts', 'settingsExcluded', 'settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy', 'wire'];
-const LATER_PLAN_KEYS = new Set(['settingsVerdicts', 'settingsExcluded', 'settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy']);
+const LATER_PLAN_KEYS = new Set(['settingsSalvage', 'moduleVerdicts', 'sessionVerdicts', 'sessionReader', 'closedBy']);
 const _planKeysPin = [true, true];
 void _planKeysPin;
 export const ENGINE_HOOK_LIMITS = { maxGroupsPerEvent: 16, maxEntriesPerEvent: 32, maxCommandChars: 8192, maxLlmEntriesPerEvent: 4 };
@@ -694,7 +694,7 @@ export function settingsHooksKeptLocally(plan, event, group, opts) {
         const planRec = plan;
         if (!isRecord(planRec))
             return hooks;
-        const excludedList = Object.hasOwn(planRec, 'settingsExcluded') ? planRec.settingsExcluded : [];
+        const excludedList = Object.hasOwn(planRec, 'settingsExcluded') ? planRec.settingsExcluded : undefined;
         const wire = ownField(planRec, 'wire');
         if (!Array.isArray(excludedList) || (wire !== undefined && !isRecord(wire)))
             return hooks;
@@ -973,13 +973,15 @@ export function userPromptSubmitExecutorOf(plan) {
         if (!Array.isArray(verdicts))
             return 'unknown';
         const rows = [...verdicts];
-        for (const k of ['settingsVerdicts', 'sessionVerdicts']) {
-            const v = ownField(p, k);
-            if (v === undefined)
-                continue;
-            if (!Array.isArray(v))
+        const settingsRows = ownField(p, 'settingsVerdicts');
+        if (!Array.isArray(settingsRows))
+            return 'unknown';
+        rows.push(...settingsRows);
+        const sessionRows = ownField(p, 'sessionVerdicts');
+        if (sessionRows !== undefined) {
+            if (!Array.isArray(sessionRows))
                 return 'unknown';
-            rows.push(...v);
+            rows.push(...sessionRows);
         }
         const ups = rows.filter((r) => isRecord(r) && ownField(r, 'event') === 'UserPromptSubmit').map((r) => ownField(r, 'disposition'));
         if (ups.length === 0)

package/dist/prepareRefusal.d.ts

@@ -0,0 +1,8 @@
+import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_TOOL_FACE_CONTROL, PROMPT_ASSEMBLED_ROLE_REFUSED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+export type PrepareRefusalCode = typeof CONFIG_LEGACY_TOOL_NAME | typeof CONFIG_IMAGE_INVALID | typeof CONFIG_AGENT_UNKNOWN_TOOL | typeof PROMPT_ASSEMBLED_ROLE_REFUSED | typeof USER_ATTACHMENT_INVALID_ERROR_CODE | typeof USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE | typeof CONFIG_TOOL_FACE_CONTROL;
+export interface PrepareRefusalNoteFacts {
+    readonly index?: number;
+}
+export declare function prepareRefusalNoteOf(code: string | undefined, facts?: PrepareRefusalNoteFacts): string | undefined;
+export declare function prepareRefusalCodeOf(failure: {} | null | undefined): PrepareRefusalCode | undefined;
+export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;

package/dist/prepareRefusal.js

@@ -0,0 +1,72 @@
+import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_IMAGE_INVALID, CONFIG_LEGACY_TOOL_NAME, CONFIG_TOOL_FACE_CONTROL, PROMPT_ASSEMBLED_ROLE_REFUSED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, } from './engineErrorCodes.js';
+import { REFUSED_NAME_CLASSES } from './hitl/refusedToolNameProse.js';
+import { readOwnDataValue } from './ownKey.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+const nonNegInt = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 ? v : undefined);
+const PREPARE_REFUSAL_NOTES = Object.freeze({
+    [CONFIG_LEGACY_TOOL_NAME]: () => `The engine refused this run at setup: a tool rule applied to it names a tool the engine refuses — ${REFUSED_NAME_CLASSES} (the engine's own error text names the entry). ` +
+        'Every later run fails the same way until that entry is removed from wherever it is set: this session’s rule record, the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules.',
+    [CONFIG_IMAGE_INVALID]: () => 'The engine refused this run at setup: an image sent with the message was not accepted — the engine’s own error text says which image and what is wrong with it. ' +
+        'Remove or replace that image, then send the message again.',
+    [CONFIG_AGENT_UNKNOWN_TOOL]: () => 'The engine refused this run at setup: a subagent tool list (in a subagent definition sent with it, or on a delegation tool) is not a list of tool names, or has an entry that names no tool or uses a form that list does not accept — ' +
+        'the engine’s own error text says which list, and which entry when it is one entry · Sending the same request again is refused the same way; fix what it names, then send it',
+    [PROMPT_ASSEMBLED_ROLE_REFUSED]: () => 'The engine refused this run at setup: the role text sent with it contains the engine’s own prompt sections word for word — the engine’s own error text names the field · ' +
+        'Send only your own role text (the engine assembles the rest), then send it again',
+    [USER_ATTACHMENT_INVALID_ERROR_CODE]: (facts) => {
+        const index = nonNegInt(facts.index);
+        return index !== undefined
+            ? `The engine refused attachment ${index + 1} of this message: it is in a form the engine does not accept, or larger than it takes · Your draft is kept · Remove or replace that attachment, then send it again`
+            : 'The engine refused the files attached to this message: together with the message they are more than it can take in one request on this model, or one of them is in a form it does not accept · ' +
+                'Your draft is kept · Remove some attachments or attach smaller parts, then send it again';
+    },
+    [USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE]: () => 'The engine refused this run at setup: a skill named for it is not one this run has loaded, or skills are turned off for this run · ' +
+        'Your draft is kept · Check the skill name, or load that skill, then send it again',
+    [CONFIG_TOOL_FACE_CONTROL]: () => 'The engine refused this run at setup: its tool set could not be put together as asked — usually a tool list on the request or one it inherits (allowed or excluded tools) names something no tool answers to, ' +
+        'uses a form those lists do not accept, or excludes a tool this run depends on; it can also be the deployment’s own tool mounts — the engine’s own error text says what it refused and where · ' +
+        'Sending the same request again is refused the same way; fix what it names (or ask whoever operates the engine, if it names the deployment’s tools), then send it',
+});
+function isPrepareRefusalCode(code) {
+    return typeof code === 'string' && Object.hasOwn(PREPARE_REFUSAL_NOTES, code);
+}
+export function prepareRefusalNoteOf(code, facts) {
+    try {
+        if (!isPrepareRefusalCode(code))
+            return undefined;
+        let index;
+        try {
+            index = facts === undefined || facts === null ? undefined : facts.index;
+        }
+        catch {
+            index = undefined;
+        }
+        const i = nonNegInt(index);
+        return PREPARE_REFUSAL_NOTES[code](i !== undefined ? { index: i } : {});
+    }
+    catch {
+        return undefined;
+    }
+}
+export function prepareRefusalCodeOf(failure) {
+    try {
+        if (typeof failure !== 'object' || failure === null)
+            return undefined;
+        const kind = readOwnDataValue(failure, 'kind');
+        const plane = readOwnDataValue(failure, 'plane');
+        if (kind === 'failed' && (plane === 'cause' || plane === 'flat')) {
+            const code = readOwnDataValue(failure, 'code');
+            return isPrepareRefusalCode(code) ? code : undefined;
+        }
+        if (readOwnDataValue(failure, 'type') === 'result') {
+            const code = readOwnDataValue(failure, '_sema_error_code');
+            return isPrepareRefusalCode(code) ? code : undefined;
+        }
+        const code = effectiveWireErrorCode(failure);
+        return isPrepareRefusalCode(code) ? code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function imageInvalidFailureNoteOf(code) {
+    return code === CONFIG_IMAGE_INVALID ? prepareRefusalNoteOf(code) : undefined;
+}

package/dist/request/taskRequest.d.ts

@@ -1,7 +1,7 @@
 import type { TaskRequest, UserAttachment } from '@sema-agent/sdk';
 import { type OutputStyleSeatReading } from '../outputStyleSeatCapability.js';
 import { type ApprovalReachWord } from '../approvalReachWire.js';
-import { type HostTurnSettings, type HostTurnSettingsInput } from '../hostTurnSettings.js';
+import { type HostSettingNotice, type HostTurnSettings, type HostTurnSettingsInput } from '../hostTurnSettings.js';
 export type RequestLane = 'interactive' | 'print' | 'utility';
 export type TaskRequestLike = Record<string, unknown>;
 export interface RequestFieldSpec {
@@ -54,8 +54,6 @@ export interface TaskRequestInput {
     fallbackModel?: string;
     maxThinkingTokens?: number;
     memoryCapture?: 'off';
-    memory?: 'off';
-    fileHistory?: TaskRequest['fileHistory'];
     inheritEnv?: InheritEnvWord;
     requireExistingSession?: TaskRequest['requireExistingSession'];
     disableSkills?: TaskRequest['disableSkills'];
@@ -63,11 +61,7 @@ export interface TaskRequestInput {
     repo?: string;
     hostSettings: HostTurnSettings;
     settings?: {
-        resolved?: never;
-        webSearch?: never;
         ultracode?: boolean;
-        hooks?: never;
-        outputStyle?: never;
     };
 }
 export declare const TASK_REQUEST_OMISSION_CAUSES: readonly ["upstream_absent", "other_channel", "off_lane", "not_live"];
@@ -101,14 +95,20 @@ export declare const UPSTREAM_ABSENT_REQUEST_INTENTS: readonly UpstreamAbsentReq
 export declare const REQUEST_LANES: readonly RequestLane[];
 export declare function taskRequestSeatOf(key: string, lane: RequestLane): TaskRequestSeatReading;
 export declare function hostTurnSettings(input: HostTurnSettingsInput): HostTurnSettings;
+export type HostSettingsRefilterResult = {
+    readonly kind: 'send';
+    readonly request: TaskRequestLike;
+    readonly hooksDropped: number;
+} | {
+    readonly kind: 'refuse';
+    readonly notice: HostSettingNotice;
+};
+export declare function refilterHostSettings(request: TaskRequestLike, fresh: HostTurnSettings, lane: RequestLane): HostSettingsRefilterResult;
 export declare const MEMORY_CAPTURE_OFF: "off";
 export declare function memoryCaptureDeclarationField(declared: boolean): {
     memoryCapture: 'off';
 } | Record<string, never>;
 export declare const MEMORY_OFF: "off";
-export declare function memoryOffDeclarationField(declared: boolean): {
-    memory: 'off';
-} | Record<string, never>;
 export declare const FILE_HISTORY_DISABLED: "disabled";
 export declare const INHERIT_ENV_WORDS: readonly ["all", "scrub"];
 export type InheritEnvWord = (typeof INHERIT_ENV_WORDS)[number];