@sema-agent/client-core 0.92.0 → 0.93.0

package/dist/retryStatus.js

@@ -47,7 +47,7 @@ export function mapBrainStatusToRetry(p, nowMs) {
         case 'reconnecting':
             return { kind: 'stalled', deadline, ...extra, ...stalledDetail };
         case 'rate_limited':
-            return { kind: 'error', deadline, ...extra, error: { formatted: '', rateLimits: {} } };
+            return { kind: 'error', deadline, ...extra, error: { formatted: p.detail ?? '', rateLimits: null } };
         case 'circuit_open':
             return {
                 kind: 'error',
@@ -60,6 +60,7 @@ export function mapBrainStatusToRetry(p, nowMs) {
         case 'waiting_first_token':
             return { kind: 'waiting', deadline, ...extra, error: { formatted: '' } };
         case 'retrying':
+            return { kind: 'error', deadline, ...extra, error: { formatted: p.detail ?? '' } };
         default:
             return { kind: 'error', deadline, ...extra, error: { formatted: '' } };
     }

package/dist/rewindArchiveCapability.js

@@ -77,7 +77,7 @@ export function rewindArchiveDoctorDetail(reading, mode) {
                 ? `${lane} off on this deployment (no file history store) — the working tree cannot be restored here; whether the conversation alone can be rewound is a separate reading`
                 : `${lane} off on this deployment — it needs both a file history store and conversation anchors, and the engine reports at least one missing (it does not say which)`;
         case 'not_reported':
-            return `${lane} not reported by this engine — only newer engines advertise it, so this does not say whether the code archive can be restored`;
+            return `${lane} not reported by this engine, so this does not say whether the code archive can be restored`;
         case 'malformed':
             return `${lane} reported in a shape this reader cannot read — the value is neither true nor false, so the answer is unknown, not "no"`;
     }
@@ -102,7 +102,7 @@ export function rewindConversationDoctorDetail(reading) {
         case 'off':
             return `${lane} off on this deployment (no conversation anchors) — the conversation cannot be moved back to an earlier message here`;
         case 'not_reported':
-            return `conversation anchors not reported by this engine — only newer engines advertise them, so this does not say whether the conversation can be rewound`;
+            return `conversation anchors not reported by this engine, so this does not say whether the conversation can be rewound`;
         case 'malformed':
             return `conversation anchors reported in a shape this reader cannot read — the value is neither true nor false, so the answer is unknown, not "no"`;
     }

package/dist/runTerminal.d.ts

@@ -16,6 +16,21 @@ export interface RunTerminalFailureDetail {
     status?: number;
     code?: string;
 }
+export declare const PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "timeout", "cancelled"];
+export type PromptBlockCause = (typeof PROMPT_BLOCK_CAUSES)[number];
+export type RunTerminalBlockedDetail = {
+    kind: 'prompt_blocked_by_hook';
+    cause: PromptBlockCause;
+    hookReason?: string;
+} | {
+    kind: 'prompt_blocked_by_hook';
+    cause: 'unrecognized';
+    word: string;
+    hookReason?: string;
+} | {
+    kind: 'unrecognized';
+    word: string;
+};
 export type RunTerminalRead = {
     kind: 'completed';
     plane: RunTerminalPlane;
@@ -31,6 +46,7 @@ export type RunTerminalRead = {
     plane: RunTerminalPlane;
     reason?: string;
     code?: string;
+    detail?: RunTerminalBlockedDetail;
 } | RunTerminalPausedRead | {
     kind: 'unknown';
     plane: RunTerminalPlane;

package/dist/runTerminal.js

@@ -1,4 +1,6 @@
-import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+import { CORE_PROMPT_BLOCK_CAUSES, CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+export const PROMPT_BLOCK_CAUSES = CORE_PROMPT_BLOCK_CAUSES;
+const PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND = 'prompt_blocked_by_hook';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
@@ -20,10 +22,13 @@ function pauseOf(v) {
         ...(restoreMode !== undefined ? { restoreMode } : {}),
     };
 }
+function ownValueOf(o, k) {
+    return Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined;
+}
 const PROVIDER_REJECTED_DETAIL_KIND = 'provider_rejected';
 function failureDetailOf(cause) {
     try {
-        const own = (o, k) => (Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
+        const own = ownValueOf;
         const v = own(cause, 'detail');
         if (typeof v !== 'object' || v === null || Array.isArray(v))
             return undefined;
@@ -41,6 +46,29 @@ function failureDetailOf(cause) {
         return undefined;
     }
 }
+function blockedDetailOf(cause) {
+    try {
+        const v = ownValueOf(cause, 'detail');
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const kind = str(ownValueOf(v, 'kind'));
+        if (kind === undefined)
+            return undefined;
+        if (kind !== PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND)
+            return { kind: 'unrecognized', word: kind };
+        const causeWord = str(ownValueOf(v, 'cause'));
+        if (causeWord === undefined)
+            return undefined;
+        const hookReason = str(ownValueOf(v, 'hookReason'));
+        const hook = hookReason !== undefined ? { hookReason } : {};
+        return PROMPT_BLOCK_CAUSES.includes(causeWord)
+            ? { kind: PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND, cause: causeWord, ...hook }
+            : { kind: PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND, cause: 'unrecognized', word: causeWord, ...hook };
+    }
+    catch {
+        return undefined;
+    }
+}
 const FLAT_PAUSED_STATUSES = ['suspended', 'needs_review'];
 export function readRunTerminal(result) {
     if (typeof result !== 'object' || result === null || Array.isArray(result))
@@ -77,7 +105,8 @@ export function readRunTerminal(result) {
             }
             case 'blocked': {
                 const reason = str(c.reason);
-                return { kind: 'blocked', plane: 'cause', ...(reason !== undefined ? { reason } : {}) };
+                const detail = blockedDetailOf(c);
+                return { kind: 'blocked', plane: 'cause', ...(reason !== undefined ? { reason } : {}), ...(detail !== undefined ? { detail } : {}) };
             }
             case 'paused':
                 return { kind: 'paused', plane: 'cause', ...(pauseOf(c) ?? {}) };

package/dist/seam.d.ts

@@ -15,6 +15,7 @@ export interface InlineTaskTick {
     totalTokens: number;
     durationMs: number;
     currentAction?: string;
+    model?: string;
 }
 export interface AdapterContext {
     sessionId: string;

package/dist/sessionPolicyCapability.js

@@ -34,7 +34,7 @@ export function sessionPolicyFaceAvailable(reading) {
 export function sessionPolicyDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'per-session rule face not observed — the engine reports it on /v1/capabilities (sessionPolicy); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'per-session rule face not observed — the engine reports it on /v1/capabilities (sessionPolicy); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
             return 'per-session rule face not reported by this engine — this binary predates the position itself; it says nothing about whether the face exists, so read the rules rather than writing them blind';
         case 'absent':

package/dist/sessionSyncFileHistoryCapability.js

@@ -33,9 +33,9 @@ export function sessionSyncFileHistoryAvailable(reading) {
 export function sessionSyncFileHistoryDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'session-sync file history not observed — the engine reports it on /v1/capabilities (sessionSyncFileHistory); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'session-sync file history not observed — the engine reports it on /v1/capabilities (sessionSyncFileHistory); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
-            return 'session-sync file history not reported by this engine — only newer engines advertise it separately; this does not say whether file history can be synced';
+            return 'session-sync file history not reported separately by this engine; this does not say whether file history can be synced';
         case 'absent':
             return 'no session-sync file history on this deployment — syncing a session moves the conversation only; edited-file history stays behind';
         case 'present':

package/dist/skillToolListsCapability.js

@@ -33,7 +33,7 @@ export function skillToolListsAvailable(reading) {
 export function skillToolListsDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'skill tool lists not observed — the engine reports it on /v1/capabilities (skillToolLists); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'skill tool lists not observed — the engine reports it on /v1/capabilities (skillToolLists); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
             return 'skill tool lists not reported by this engine — the engine predates them: tool lists on request skills are not read, so they do not limit any tool';
         case 'absent':

package/dist/sqlEngineCapability.js

@@ -52,7 +52,7 @@ export function sqlEngineDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('not observed — the engine reports it on /v1/capabilities; this process has no usable ' +
-                'capabilities reading cached for it (none received, or the last one was unreadable)');
+                'capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
             return 'not reported by this engine — the capability position needs a newer engine';
         case 'none':

package/dist/steerPriorityCapability.js

@@ -61,7 +61,7 @@ export function steerPriorityDoctorDetail(reading) {
         return unobserved;
     }
     if (kind === 'not_reported') {
-        return 'steer priority not reported by this engine — it predates the field or has no fleet face, so a "now" or "later" steer is not sent (steers without a priority work as before)';
+        return 'steer priority not reported by this engine — its capabilities reading carries no fleet.steerPriority (the fleet face is not reported, or the face carries no such field; this client cannot tell which), so a "now" or "later" steer is not sent (steers without a priority work as before)';
     }
     if (kind !== 'present' || typeof word !== 'string' || word.length === 0)
         return unobserved;

package/dist/storePostureCapability.js

@@ -90,7 +90,7 @@ export function storePostureDoctorDetail(reading) {
     const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
     const r = presentView(reading);
     if (r?.kind === 'not_reported') {
-        return 'store posture not reported by this engine — only newer engines advertise it; this does not say whether this deployment persists its state';
+        return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
     }
     if (r?.kind !== 'present')
         return unobserved;
@@ -120,7 +120,7 @@ export function storePostureDoctorDetail(reading) {
         return `${assembled} — ${lost} (degraded: the declared database could not be opened at start-up, so the engine fell back rather than refusing to start)`;
     }
     if (reason === 'local_unwritable') {
-        return `${assembled} — ${lost} (degraded: the default local file store could not be created, for example a read-only or full data directory)`;
+        return `${assembled} — ${lost} (degraded: the default local file store could not be created — a read-only or full data directory is one possible cause, and this client cannot tell which applies)`;
     }
     return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
 }

package/dist/supportFloor.d.ts

@@ -8,3 +8,4 @@ export declare const SUPPORT_FLOOR: Readonly<SupportFloor>;
 export declare function supportFloorOf(component: unknown): string | undefined;
 export type EngineVersionTier = 'engine' | 'legacy' | 'unknown';
 export declare function engineVersionTier(version: unknown, floor?: string): EngineVersionTier;
+export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;

package/dist/supportFloor.js

@@ -25,12 +25,16 @@ function compareTriple(a, b) {
     }
     return 0;
 }
-export function engineVersionTier(version, floor) {
-    let need = releaseTriple(SUPPORT_FLOOR.server);
+function versionTierAgainst(version, base, floor, caller) {
+    const baseTriple = releaseTriple(base);
+    if (baseTriple === undefined) {
+        throw new TypeError(`${caller}: 门槛只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)—— 收到 typeof=${base === null ? 'null' : typeof base}。错误文本只报形状,不回显值。`);
+    }
+    let need = baseTriple;
     if (floor !== undefined) {
         const own = releaseTriple(floor);
         if (own === undefined) {
-            throw new TypeError(`engineVersionTier: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
+            throw new TypeError(`${caller}: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
         }
         if (compareTriple(own, need) > 0)
             need = own;
@@ -40,3 +44,9 @@ export function engineVersionTier(version, floor) {
         return 'unknown';
     return compareTriple(got, need) >= 0 ? 'engine' : 'legacy';
 }
+export function engineVersionTier(version, floor) {
+    return versionTierAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier');
+}
+export function coreVersionTier(version, floor) {
+    return versionTierAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier');
+}

package/dist/taskRequestWords.d.ts

@@ -1,8 +1,9 @@
 import type { TaskRequest } from '@sema-agent/sdk';
 export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffort']>;
 export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
-export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto"];
+type SdkTaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
+export type TaskRequestPermissionMode = SdkTaskRequestPermissionMode | 'dontAsk';
+export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto", "dontAsk"];
 export interface RetiredAttachmentsKey {
     readonly key: string;
     readonly why: string;
@@ -10,3 +11,4 @@ export interface RetiredAttachmentsKey {
     readonly remedy: string;
 }
 export declare function retiredAttachmentsKeyOf(nameOrToken: string, form?: 'token' | 'key'): RetiredAttachmentsKey | undefined;
+export {};

package/dist/taskRequestWords.js

@@ -1,5 +1,5 @@
 export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
+export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto', 'dontAsk'];
 const _taskRequestWordPins = [true, true, true, true];
 void _taskRequestWordPins;
 export function retiredAttachmentsKeyOf(nameOrToken, form = 'token') {

package/dist/toolHistoryBadTurn.js

@@ -2,8 +2,7 @@ import { displayUntrusted } from './displayUntrusted.js';
 const BAD_TURN_PREVIEW_MAX = 60;
 export function toolHistoryBadTurnSentence(promptText) {
     const text = typeof promptText === 'string' ? promptText : '';
-    const flat = stripDisplayTagBlocks(text).replace(/\s+/g, ' ').trim();
-    const washed = displayUntrusted(flat, { foldLines: false, mark: 'dot' });
+    const washed = displayUntrusted(stripDisplayTagBlocks(text), { mark: 'dot' }).replace(/\s+/g, ' ').trim();
     const points = Array.from(washed);
     const preview = points.length > BAD_TURN_PREVIEW_MAX ? `${points.slice(0, BAD_TURN_PREVIEW_MAX).join('')}...` : washed;
     return preview.length > 0

package/dist/toolResult.d.ts

@@ -100,7 +100,8 @@ export interface EngineBgShellRegistration {
     receipt: string;
     source: 'bash' | 'monitor';
 }
-export declare function detectEngineBgShellReceipt(toolName: string, rawInput: unknown, outputText: string | undefined): EngineBgShellRegistration | null;
+export declare function detectEngineBgShellReceipt(toolName: string, rawInput: unknown, outputText: string | undefined, structured?: unknown): EngineBgShellRegistration | null;
+export declare function detectEngineBgShellDetach(toolName: string, rawInput: unknown, structured: unknown, outputText: string | undefined): EngineBgShellRegistration | null;
 export declare function todoWriteToolUseResult(rawInput: unknown, oldTodos: unknown[], isError: boolean): {
     toolUseResult: unknown;
     isError: boolean;

package/dist/toolResult.js

@@ -674,7 +674,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
             return null;
     }
 }
-export function detectEngineBgShellReceipt(toolName, rawInput, outputText) {
+export function detectEngineBgShellReceipt(toolName, rawInput, outputText, structured) {
     if (typeof outputText !== 'string')
         return null;
     const input = (rawInput ?? {});
@@ -683,6 +683,8 @@ export function detectEngineBgShellReceipt(toolName, rawInput, outputText) {
     if (toolName === 'Bash') {
         if (input.run_in_background !== true)
             return null;
+        if (readBashDetachView(structured)?.registerFailed === true)
+            return null;
         m = THREE_GEN_BG_RECEIPT_RE.exec(outputText);
         source = 'bash';
     }
@@ -695,17 +697,45 @@ export function detectEngineBgShellReceipt(toolName, rawInput, outputText) {
     }
     if (!m?.[1])
         return null;
+    return engineBgShellRegistrationBody(m[1], input, outputText, source);
+}
+function engineBgShellRegistrationBody(taskId, rawInput, receipt, source) {
+    const input = (rawInput ?? {});
     const command = typeof input.command === 'string' ? input.command : '(engine bash)';
     const description = typeof input.description === 'string' ? input.description : undefined;
     return {
         kind: 'register',
-        taskId: m[1],
+        taskId,
         command,
         ...(description !== undefined ? { description } : {}),
-        receipt: outputText,
+        receipt,
         source,
     };
 }
+export function detectEngineBgShellDetach(toolName, rawInput, structured, outputText) {
+    if (toolName !== 'Bash')
+        return null;
+    const view = readBashDetachView(structured);
+    if (view === null || !view.detached || view.registerFailed || view.taskId === undefined)
+        return null;
+    return engineBgShellRegistrationBody(view.taskId, rawInput, typeof outputText === 'string' ? outputText : '', 'bash');
+}
+function readBashDetachView(structured) {
+    if (typeof structured !== 'object' || structured === null)
+        return null;
+    const s = structured;
+    const type = s.type;
+    if (type !== 'bash')
+        return null;
+    const detached = s.detached;
+    const registerFailed = s.registerFailed;
+    const taskId = s.task_id;
+    return {
+        detached: detached === true,
+        registerFailed: registerFailed === true,
+        taskId: typeof taskId === 'string' && taskId.length > 0 ? taskId : undefined,
+    };
+}
 export function todoWriteToolUseResult(rawInput, oldTodos, isError) {
     const todos = rawInput?.todos;
     if (!Array.isArray(todos))

package/dist/userInvokedSkillsCapability.js

@@ -33,7 +33,7 @@ export function userInvokedSkillsAvailable(reading) {
 export function userInvokedSkillsDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
             return 'user-invoked skills not reported by this engine — the engine predates it, so naming skills on a request is refused (do not send the key)';
         case 'absent':

package/dist/webSearchBackendCapability.js

@@ -38,9 +38,9 @@ export function webSearchBackendDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('deployment default backend not observed — the engine reports it on /v1/capabilities; ' +
-                'this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)');
+                'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
-            return ('deployment default backend not reported by this engine — only newer engines advertise it; ' +
+            return ('deployment default backend not reported by this engine; ' +
                 'this does not say whether the deployment has a search backend');
         case 'none':
             return (`deployment default backend none — ${DEPLOY_ENV} is unset or not a provider word on the engine, ` +

package/dist/webSearchWireCaps.d.ts

@@ -22,7 +22,7 @@ export type WebSearchSettingsVerdict = {
     settings: WebSearchSettings;
 } | {
     kind: 'malformed';
-    source: 'env' | 'settings';
+    source: 'env' | 'settings' | 'host';
     field: WebSearchSettingsField;
     issue: string;
 };

package/dist/webSearchWireCaps.js

@@ -32,6 +32,37 @@ function judgeText(raw) {
         return { ok: false, issue: 'must be a string' };
     return { ok: true, value: isBlankText(raw) ? undefined : raw };
 }
+const API_KEY_ISSUE = 'must be usable as an HTTP header value (it contains a character an HTTP header cannot carry, such as a line break)';
+const isHttpWhitespaceCode = (c) => c === 0x09 || c === 0x0a || c === 0x0d || c === 0x20;
+function isHttpHeaderValue(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && isHttpWhitespaceCode(value.charCodeAt(start)))
+        start++;
+    while (end > start && isHttpWhitespaceCode(value.charCodeAt(end - 1)))
+        end--;
+    for (let i = start; i < end; i++) {
+        const c = value.charCodeAt(i);
+        if (!(c === 0x09 || (c >= 0x20 && c <= 0x7e) || (c >= 0x80 && c <= 0xff)))
+            return false;
+    }
+    return true;
+}
+function apiKeyHeaderValue(provider, key) {
+    switch (provider) {
+        case 'brave':
+        case 'searxng':
+            return key;
+        case 'tavily':
+            return `Bearer ${key}`;
+    }
+}
+function judgeApiKey(provider, raw) {
+    const text = judgeText(raw);
+    if (!text.ok || text.value === undefined)
+        return text;
+    return isHttpHeaderValue(apiKeyHeaderValue(provider, text.value)) ? text : { ok: false, issue: API_KEY_ISSUE };
+}
 const ENDPOINT_ISSUE = 'must be an absolute URL with a scheme and a host, such as https://search.example.com (a bare host or host:port is not one)';
 function judgeEndpoint(raw) {
     if (raw === undefined || raw === null)
@@ -114,9 +145,10 @@ function judgeSection(raw, source, apiKeyFor) {
             injected = undefined;
         }
     }
-    const apiKey = typeof injected === 'string' && !isBlankText(injected) ? { ok: true, value: injected } : judgeText(s.apiKey);
+    const useInjected = typeof injected === 'string' && !isBlankText(injected);
+    const apiKey = judgeApiKey(provider.value, useInjected ? injected : s.apiKey);
     if (!apiKey.ok)
-        return { kind: 'malformed', source, field: 'apiKey', issue: apiKey.issue };
+        return { kind: 'malformed', source: useInjected ? 'host' : source, field: 'apiKey', issue: apiKey.issue };
     const endpoint = judgeEndpoint(s.endpoint);
     if (!endpoint.ok)
         return { kind: 'malformed', source, field: 'endpoint', issue: endpoint.issue };
@@ -191,6 +223,12 @@ function envNameOfField(field) {
 export function webSearchVerdictMessage(verdict, context = 'submit') {
     if (verdict.kind !== 'malformed')
         return undefined;
+    if (verdict.source === 'host') {
+        const head = `Web search is misconfigured: the API key your host supplied for webSearch is malformed; it ${verdict.issue}.`;
+        return context === 'submit'
+            ? `${head} The request was not sent — the key needs replacing where your host keeps it.`
+            : `${head} Requests will be refused until the key is replaced where your host keeps it.`;
+    }
     const where = verdict.source === 'env' ? envNameOfField(verdict.field) : verdict.field === 'section' ? 'the webSearch section in settings' : `webSearch.${verdict.field} in settings`;
     const fix = verdict.source === 'env' ? 'fix it or unset the SEMA_WEBSEARCH_* variables' : 'fix it or remove the webSearch section';
     return context === 'submit'

package/dist/wireFailureShape.js

@@ -66,9 +66,9 @@ export function readErrorStrictStringList(o, key) {
         return true;
     };
     const v = readErrorSlot(o, key, strict);
-    if (!Array.isArray(v))
-        return undefined;
     try {
+        if (!Array.isArray(v))
+            return undefined;
         const out = [];
         const len = v.length;
         for (let i = 0; i < len; i++) {

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
@@ -22,14 +22,20 @@ export interface FleetLeaseUnavailableDetail {
 }
 export declare function fleetLeaseUnavailableFromError(err: unknown): FleetLeaseUnavailableDetail | null;
 export declare function fleetLeaseUnavailableContent(detail: FleetLeaseUnavailableDetail): string;
-export type DenyAttributionRefusalKind = 'not_in_proof' | 'decision_conflict' | 'attribution_rejected';
+export interface ScenarioAssignmentUnknownDetail {
+    code: typeof SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE;
+    scenario?: string;
+    source?: 'ruling' | 'deployment';
+}
+export declare function scenarioAssignmentUnknownFromError(err: unknown): ScenarioAssignmentUnknownDetail | null;
+export type DenyAttributionRefusalKind = 'not_in_proof' | 'decision_conflict' | 'attribution_rejected' | 'retired_key';
 export interface DenyAttributionRefusalDetail {
     kind: DenyAttributionRefusalKind;
     code: string;
     status: number;
     field?: string;
 }
-export declare function denyAttributionRefusalFromError(err: unknown, sentSettledBy: boolean): DenyAttributionRefusalDetail | null;
+export declare function denyAttributionRefusalFromError(err: unknown, sentAttributionKey: boolean): DenyAttributionRefusalDetail | null;
 export declare function denyAttributionRefusalContent(detail: Pick<DenyAttributionRefusalDetail, 'kind' | 'field'>): string;
 export declare const CONFLICT_SESSION_CHILDREN_ALIVE = "conflict.session_children_alive";
 export type SessionDeleteConflictKind = 'children_alive' | 'active_run' | 'unrecognized';

package/dist/wireRefusalCopy.js

@@ -1,6 +1,6 @@
 import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
@@ -145,7 +145,38 @@ export function fleetLeaseUnavailableContent(detail) {
         : ' · The engine did not say how long to wait — send it again a little later';
     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';
 const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';
 const APPROVAL_NON_BINDING_FIELDS = new Set(['hostDecision', 'approver']);
 function readRefusalField(o) {
@@ -163,7 +194,7 @@ function readRefusalField(o) {
     }
     return readStringField(o, 'field');
 }
-export function denyAttributionRefusalFromError(err, sentSettledBy) {
+export function denyAttributionRefusalFromError(err, sentAttributionKey) {
     try {
         if (err === null || typeof err !== 'object')
             return null;
@@ -175,9 +206,12 @@ export function denyAttributionRefusalFromError(err, sentSettledBy) {
         const code = readStringField(o, 'errorCode');
         if (code === undefined)
             return null;
-        if (status === 400 && code === SETTLED_BY_NOT_IN_PROOF)
+        if (status === 400 && (code === SETTLED_BY_NOT_IN_PROOF || code === DECIDED_BY_NOT_IN_PROOF))
             return { kind: 'not_in_proof', code, status };
-        if (status === 400 && code === REQUEST_FIELD_CONFLICT && sentSettledBy) {
+        if (status === 400 && code === BODY_SHAPE && readRefusalField(o) === RETIRED_DECISION_KEY) {
+            return { kind: 'retired_key', code, status, field: RETIRED_DECISION_KEY };
+        }
+        if (status === 400 && code === REQUEST_FIELD_CONFLICT && sentAttributionKey) {
             return { kind: 'decision_conflict', code, status };
         }
         if (status === 409 && code === RESUME_OUTCOME_INVALID) {
@@ -202,6 +236,9 @@ export function denyAttributionRefusalContent(detail) {
             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');
+        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');
         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.`

package/dist/workflowsJournalCapability.js

@@ -33,7 +33,7 @@ export function workflowsJournalAvailable(reading) {
 export function workflowsJournalDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
-            return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+            return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
         case 'not_reported':
             return 'workflow journal not reported by this engine — the engine predates the separate flag, so the workflow listing flag still covers the journal';
         case 'absent':

package/dist/writeProtectionCapability.js

@@ -75,7 +75,7 @@ export function writeProtectionDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('not observed — the engine reports it on /v1/capabilities; this process has no usable ' +
-                'capabilities reading cached for it (none received, or the last one was unreadable)');
+                'capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
             return ('not reported by this engine — the capability position needs a newer engine; this says ' +
                 'nothing about whether a protected-name table is in effect (an absent seat is the engine ' +