@sema-agent/client-core 0.91.0 → 0.92.0

package/dist/pluginHooksWire.js

@@ -1,15 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
-export const ENGINE_FIRED_HOOK_EVENTS = [
-    'PreToolUse',
-    'PostToolUse',
-    'PostToolUseFailure',
-    'PostToolBatch',
-    'PreCompact',
-    'PostCompact',
-    'Stop',
-    'StopFailure',
-    'UserPromptSubmit',
-];
+import { SETTINGS_ENGINE_OWNED_HOOK_EVENTS } from './generated/settingsSchemaTables.js';
+export const ENGINE_FIRED_HOOK_EVENTS = SETTINGS_ENGINE_OWNED_HOOK_EVENTS;
 export const PLUGIN_HOOK_DISPOSITIONS = ['engine', 'shell', 'not_run'];
 export const PLUGIN_HOOK_REASONS = [
     'projected',

package/dist/promptProfileWireCaps.d.ts

@@ -1,3 +1,4 @@
+import type { TaskRequest } from '@sema-agent/sdk';
 import { type EnvLike } from './hostEnv.js';
-export type PromptProfile = 'simple' | 'classic';
+export type PromptProfile = NonNullable<TaskRequest['promptProfile']>;
 export declare function promptProfileFromEnv(env?: EnvLike): PromptProfile | undefined;

package/dist/protocolSegment.d.ts

@@ -0,0 +1,9 @@
+export type ProtocolSegment = {
+    readonly kind: 'ok';
+} | {
+    readonly kind: 'unminted';
+    readonly minted?: string;
+} | {
+    readonly kind: 'unknown';
+};
+export declare function protocolSegmentOf(name: string): ProtocolSegment;

package/dist/protocolSegment.js

@@ -0,0 +1,28 @@
+import { hasCoreValuePort, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
+export function protocolSegmentOf(name) {
+    const ns = protocolOf(name);
+    if (ns === undefined)
+        return hasCoreValuePort('protocolOf') ? { kind: 'ok' } : { kind: 'unknown' };
+    let parsed;
+    try {
+        parsed = ns.parse(name);
+    }
+    catch {
+        return { kind: 'unknown' };
+    }
+    const peer = parsed?.peer;
+    if (typeof peer !== 'string')
+        return { kind: 'ok' };
+    if (peer.includes('*'))
+        return { kind: 'unminted' };
+    let minted;
+    try {
+        minted = mintNamespacePrefix(ns, peer);
+    }
+    catch {
+        return { kind: 'unknown' };
+    }
+    if (typeof minted !== 'string')
+        return { kind: 'unknown' };
+    return minted === `${ns.prefix}${peer}__` ? { kind: 'ok' } : { kind: 'unminted', minted };
+}

package/dist/request/taskRequest.js

@@ -44,7 +44,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'systemPrompt', lanes: ['interactive', 'print', 'utility'], live: false, why: '整段替换系统提示(sdk `TaskRequest.systemPrompt`;上游字符数超限 400 响亮拒,本层原样透传)。三条车道都有来源:交互面 = CC QueryParams.systemPrompt,无人值守面 = `--system-prompt[-file]` 一类旗,side-channel 面 = 壳整段给出的那一份。与追加位 `appendSystemPrompt` 不是一个位(那一位归 live 兜底层,见 `LIVE_DEFAULT_FIELDS`)', whyUtilityLane: '有座:side-channel 提交的系统提示由壳整段给出 —— 它不是用户会话的续谈,不该继承用户那一份' },
     { field: 'reasoningEffort', lanes: ['interactive', 'print', 'utility'], live: false, why: '思考档位(sdk `TaskRequest.reasoningEffort` 七词闭集;上游对表外词 400 响亮拒 ⇒ 本层不预铸第二判官)。档位是请求级的位、与车道无关:交互面 = `/effort` 拨盘,无人值守面 = 档位旗。🔴 端交的必须是**档位词**:「思考 token 数」今天没有上游对位(见 `UPSTREAM_ABSENT_REQUEST_INTENTS` 的 `maxThinkingTokens`),别把一个数字折成档位词发出去', whyUtilityLane: '有座:side-channel 该用显式低档(省钱省时);与 model 同一条理由 —— 本车道上这两位都由壳显式给,不跟用户会话的拨盘走' },
     { field: 'model', lanes: ['interactive', 'print', 'utility'], live: false, why: '模型选择(sdk `TaskRequest.model`;交互面 = `/model` 中途换模型的拨盘,无人值守面 = 模型旗 / 部署缺省那一路,side-channel 面 = 壳显式挑的那一只)。三条车道都有来源、都是提交面。🔴 0.79.0 改口:修前「print 的模型走另一条路」这句理由被用户面实测证伪 —— 无人值守车道传了模型名却整键不上请求体,于是同一个坏名字在交互态被引擎 400 点名、在无人值守态却安静换成部署缺省并在首帧回显一个没生效的名字。一个**选择**类声明被静默丢掉,后果与收紧类声明被静默丢掉同形(端不读回执就以为生效)—— 与 `excludeTools` 补 print 座同律。本层原样透传、不预判模型名(名字的合法性归引擎,本层不铸第二判官)', whyUtilityLane: '有座:side-channel 显式挑便宜的那只模型(不跟用户会话的 `/model` 拨盘走)' },
-    { field: 'images', lanes: ['interactive'], live: false, why: '贴图提交是交互动作,`-p` 的 stdin 没有图片块', whyUtilityLane: '无座:贴图是交互动作,side-channel 的提交体里没有图片块' },
+    { field: 'images', lanes: ['interactive', 'print'], live: false, why: '图片输入(sdk `TaskRequest.images`;base64 / url 两形,原样透传)。两条用户车道都是提交面、都有来源:交互面 = 粘贴图与 `@` 图片像素,一次性车道 = 结构化输入里的图片块。张数、单张与合计的座位判定归人类提交装配口 `encodeHumanTurn`(两条车道同一份判定,本表不另判);请求体与图片张数的上限归上游判', whyUtilityLane: '无座:贴图是交互动作,side-channel 的提交体里没有图片块' },
     { field: 'resumeAt/resumeAtMode/restoreFiles/rewindFilesTo', lanes: ['interactive'], live: false, why: 'E18 `/rewind` 是交互命令;四键同生同灭(CC-145:core 6.0.0 起 both 臂发 restoreFiles;CC-223 起退役键 rewindFiles 不再有座 —— 交它按表外子键响亮拒;resumeAtMode 是 both/conversation 两臂恒带的排他截语义位)', whyUtilityLane: '无座:回退是交互命令,而 side-channel 是一次性的独立会话,没有可回退的历史' },
     { field: 'clientContext', lanes: ['interactive'], live: false, why: 'IANA 时区 + 可选邮箱 → core 本地化 `# Environment` 的 today;print 同样跑在用户机器上,缺席让引擎误标 (UTC)', gap: true, whyUtilityLane: '无座:本地化 today 的用途在用户会话的环境段,而 side-channel 的系统提示由壳整段给出 —— 这一列我判不准要不要(与本行 `gap` 同一条待办:要补先单独立项)' },
     { field: 'scratchpadDir', lanes: ['interactive'], live: true, why: '[816]③ per-session 暂存目录;print 也有 session,缺席让 `-p` 的工具写不进 exemptDir', gap: true, whyUtilityLane: '无座:per-session 暂存目录是给**工具**写的,零工具面上没人写' },
@@ -483,13 +483,6 @@ const refuseBadExcludeAllTools = (v) => {
         `收到 ${coarseShape(v)}。这一位是**整只工具面卸载**的收紧声明:本层若把坏值静默删键,这一次运行会挂上声明人以为已经卸掉的全部工具。` +
         '错误文本只报形状,不回显值。');
 };
-const RETIRED_APPROVER_POSTURE_KEY = 'approverPosture';
-const refuseRetiredApproverPosture = () => {
-    throw new TypeError('buildTaskRequest: "approverPosture" 是退役键(引擎 core 7.34.0 起在任务规格入口按名拒收;服务端 7.106.0 起提交体带它整条 400 ' +
-        'request.body_shape,unknownKeys 点名它)。它只是一句渲给模型看的审批姿态声明,从不授权任何东西 —— 删掉它不改变这一次运行被允许做什么。' +
-        '本包在装配前拒:在场即拒,任何值同判(undefined / null = 缺席)。处置:删掉这个键,不要改发别的键来顶替它;' +
-        '若确实要引擎侧放行审批,那是另一件事:显式给权限模式 permissionMode(那是一项授权,受部署策略管)。错误文本只报键名,不回显值。');
-};
 const refuseBadFileHistory = (v) => {
     if (v === undefined || v === null)
         return;
@@ -715,17 +708,12 @@ export function assembleTaskRequest(input, lane) {
     };
     const unknownKeys = [];
     const lateOmitted = [];
-    let retiredApproverPosture = false;
     for (const key of Object.keys(src)) {
         if (hasOwn(INPUT_KEY_ROUTES, key))
             continue;
         const stray = Reflect.get(src, key);
         if (!present(stray))
             continue;
-        if (key === RETIRED_APPROVER_POSTURE_KEY) {
-            retiredApproverPosture = true;
-            continue;
-        }
         const route = routeOfTopLevelKey(key);
         if (route === undefined) {
             unknownKeys.push(key);
@@ -756,8 +744,6 @@ export function assembleTaskRequest(input, lane) {
             retiredRewindFiles = true;
         unknownKeys.push(`rewind.${sub}`);
     }
-    if (retiredApproverPosture)
-        refuseRetiredApproverPosture();
     if (retiredRewindFiles) {
         throw new TypeError('buildTaskRequest: "rewind.rewindFiles" 是退役键(引擎 core 6.0.0 起退役:「逐轮捕获」那一义被引擎忽略 —— 文件首触追踪恒开,' +
             '无需请求;「回退时一并还原文件」那一义被引擎拒收、改名为 restoreFiles)。本包在装配前拒:在场即拒,true / false 同判。' +

package/dist/ruleCompileVerdict.d.ts

@@ -0,0 +1,2 @@
+export type RuleCompileVerdict = 'compiles' | 'refused' | 'unknown';
+export declare function ruleCompileVerdict(rule: string, behavior: 'deny' | 'ask'): RuleCompileVerdict;

package/dist/ruleCompileVerdict.js

@@ -0,0 +1,13 @@
+import { validatePermissionRules } from './coreValuePorts.js';
+const RULE_COMPILE_ROOT = '/';
+export function ruleCompileVerdict(rule, behavior) {
+    try {
+        const issues = validatePermissionRules([{ rule, behavior }], { pathBases: { root: RULE_COMPILE_ROOT } });
+        if (!Array.isArray(issues))
+            return 'unknown';
+        return issues.length === 0 ? 'compiles' : 'refused';
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/dist/ruleRemovalConsequence.d.ts

@@ -1,3 +1,4 @@
-export type RuleRemovalBehavior = 'allow' | 'deny' | 'ask' | undefined;
+import type { RuleBehavior } from '@sema-agent/sdk';
+export type RuleRemovalBehavior = RuleBehavior | undefined;
 export declare function removalConsequenceLineForBehavior(behavior: RuleRemovalBehavior): string;
 export declare function ruleRemovalBehaviorOf(raw: unknown): RuleRemovalBehavior;

package/dist/runCancelContext.d.ts

@@ -15,6 +15,7 @@ import { type RunTerminalRead } from './runTerminal.js';
 export type RunAbortCause = {
     kind: 'cancelled';
     context?: RunCancelContextView;
+    cause?: AbortCauseReading;
 } | {
     kind: 'engine_error';
     code?: string;
@@ -28,3 +29,14 @@ export type RunAbortCause = {
 };
 export declare const RUN_CANCELLED_CODE: "cancelled";
 export declare function classifyRunAbortCause(record: unknown): RunAbortCause;
+export declare const ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
+export type AbortCause = (typeof ABORT_CAUSES)[number];
+export type AbortCauseReading = {
+    readonly kind: 'known';
+    readonly cause: AbortCause;
+} | {
+    readonly kind: 'unrecognized';
+    readonly word: string;
+};
+export declare function readAbortCause(frame: unknown): AbortCauseReading | undefined;
+export declare function abortCauseNoteOf(frame: unknown): string | undefined;

package/dist/runCancelContext.js

@@ -45,7 +45,8 @@ export function classifyRunAbortCause(record) {
     if (read !== null && read.kind === 'failed') {
         if (read.code === RUN_CANCELLED_CODE) {
             const cc = readRunCancelContext(record);
-            return { kind: 'cancelled', ...(cc?.kind === 'present' ? { context: cc.context } : {}) };
+            const cause = readAbortCause(record);
+            return { kind: 'cancelled', ...(cc?.kind === 'present' ? { context: cc.context } : {}), ...(cause !== undefined ? { cause } : {}) };
         }
         return { kind: 'engine_error', ...(read.code !== undefined ? { code: read.code } : {}), ...(read.message !== undefined ? { message: read.message } : {}) };
     }
@@ -55,3 +56,84 @@ export function classifyRunAbortCause(record) {
         return { kind: 'run_still_live', status };
     return { kind: 'unknown', ...(read !== null ? { terminal: read.kind } : {}) };
 }
+export const ABORT_CAUSES = Object.freeze(['client_disconnected', 'ask_park_grace_exhausted', 'cancel_verb']);
+function ownDataOf(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+}
+function plainRecordOf(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+}
+function cancelledHolderOf(frame) {
+    const f = plainRecordOf(frame);
+    if (f === undefined)
+        return undefined;
+    const type = ownDataOf(f, 'type');
+    if (type === 'failed')
+        return ownDataOf(f, 'errorCode') === RUN_CANCELLED_CODE ? f : undefined;
+    const base = plainRecordOf(type === 'done' ? ownDataOf(f, 'result') : f);
+    if (base === undefined)
+        return undefined;
+    const holder = runResultHolder(base);
+    const t = readRunTerminal(holder);
+    return t !== null && t.kind === 'failed' && t.code === RUN_CANCELLED_CODE ? holder : undefined;
+}
+function abortCauseIn(holder) {
+    const raw = ownDataOf(holder, 'abortCause');
+    if (typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    return ABORT_CAUSES.includes(raw) ? { kind: 'known', cause: raw } : { kind: 'unrecognized', word: raw };
+}
+export function readAbortCause(frame) {
+    try {
+        const holder = cancelledHolderOf(frame);
+        return holder === undefined ? undefined : abortCauseIn(holder);
+    }
+    catch {
+        return undefined;
+    }
+}
+const ABORT_CAUSE_SENTENCES = Object.freeze({
+    client_disconnected: 'Aborted: the stream connection to the engine dropped, and the engine stopped the run (cause client_disconnected) — not an engine error.',
+    ask_park_grace_exhausted: 'Aborted: the connection dropped while a question or approval was pending, and the run could not be parked for later resumption in time ' +
+        '(cause ask_park_grace_exhausted) — not an engine error.',
+    cancel_verb: 'Cancelled: a cancel request to the engine stopped this run (cause cancel_verb) — not an engine error.',
+});
+const ABORT_CAUSE_UNRECOGNIZED_SENTENCE = 'Aborted by the engine for a reason this client does not recognize — not an engine error.';
+function secondsText(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function cancelContextOf(holder) {
+    try {
+        const r = readRunCancelContext(holder);
+        return r?.kind === 'present' ? r.context : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function cancelContextTail(ctx) {
+    if (ctx === undefined)
+        return '';
+    const parts = [];
+    if (ctx.elapsedMs !== undefined)
+        parts.push(`ran ${secondsText(ctx.elapsedMs)}`);
+    if (ctx.lastEventAgeMs !== undefined)
+        parts.push(`last engine activity ${secondsText(ctx.lastEventAgeMs)} before the stop`);
+    return parts.length > 0 ? ` (${parts.join('; ')})` : '';
+}
+export function abortCauseNoteOf(frame) {
+    try {
+        const holder = cancelledHolderOf(frame);
+        if (holder === undefined)
+            return undefined;
+        const cause = abortCauseIn(holder);
+        if (cause === undefined)
+            return undefined;
+        const sentence = cause.kind === 'known' ? ABORT_CAUSE_SENTENCES[cause.cause] : ABORT_CAUSE_UNRECOGNIZED_SENTENCE;
+        return `${sentence}${cancelContextTail(cancelContextOf(holder))}`;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/seam.js

@@ -94,7 +94,7 @@ const CHROME_ARM_TABLE = {
     },
     tool_progress: {
         required: false,
-        duty: 'CC-08(0.71.0,C-R50 一帧两拍):按 `toolCallId` 挂到那张工具卡上;`elapsedSeconds` 缺席不是 0、不等于 tool_end 的 duration;' +
+        duty: 'CC-08(0.71.0,一帧两拍):按 `toolCallId` 挂到那张工具卡上;`elapsedSeconds` 缺席不是 0、不等于 tool_end 的 duration;' +
             '`output` 在场 = 命令尾巴窗口(活面板,不是日志;`totalLines`/`totalBytes` 与它同进同退),🔴 它是 UNTRUSTED RAW,可再封顶展示、**绝不回喂**模型;' +
             '子代工具的进度不在这条臂上(三键断闸),fleet 面板另有口。不接 = 看不见进度,不属行为丢失。',
     },

package/dist/seatContract.d.ts

@@ -4,6 +4,7 @@ import type { LaneProof } from "./seam.js";
 import type { QuestionAnswer } from "./liveQuestionStore.js";
 import type { ToolApprovalDelegation } from "./hitl/toolApprovalWire.js";
 import type { ApprovalMandateWord } from "./gateVocabulary.js";
+import type { ModelApiWord } from "./model/providerPresets.js";
 export interface SeatValidationFailure {
     reason: string;
     field?: string;
@@ -240,7 +241,7 @@ export interface SeatCatalogEntry {
     providerId: string;
     providerName: string;
     baseUrl: string;
-    api: "anthropic-messages" | "openai-completions";
+    api: ModelApiWord;
     apiKey?: string;
     modelId: string;
     contextWindow: number;

package/dist/sessionMemoryStatus.d.ts

@@ -1,4 +1,4 @@
-import type { SessionMemoryStatus } from '@sema-agent/sdk';
+import type { SessionMemoryStatus, SessionMemoryStatusResponse } from '@sema-agent/sdk';
 export interface MemoryStatusClientLike {
     sessions: {
         memoryStatus(sessionId: string, opts?: {
@@ -8,9 +8,7 @@ export interface MemoryStatusClientLike {
         } & SessionMemoryStatus>;
     };
 }
-export type MemoryStatusFacts = SessionMemoryStatus & {
-    readonly autoConsolidationArmed?: boolean;
-};
+export type MemoryStatusFacts = Omit<SessionMemoryStatusResponse, 'sessionId'>;
 export type MemoryStatusVerdict = {
     readonly kind: 'ok';
     readonly sessionId: string;

package/dist/sessionSyncFileHistoryCapability.d.ts

@@ -0,0 +1,18 @@
+export type SessionSyncFileHistoryReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectSessionSyncFileHistoryCapability(caps: unknown): SessionSyncFileHistoryReading | undefined;
+export declare function noteEngineCapsForSessionSyncFileHistory(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedSessionSyncFileHistory(baseUrl?: string | undefined): SessionSyncFileHistoryReading;
+export declare function sessionSyncFileHistoryAvailable(reading: SessionSyncFileHistoryReading): 'yes' | 'no' | 'unknown';
+export declare function sessionSyncFileHistoryDoctorDetail(reading: SessionSyncFileHistoryReading): string;
+export declare function forgetSessionSyncFileHistoryReading(baseUrl: string | undefined): void;
+export declare function __resetSessionSyncFileHistoryReadingsForTests(): void;

package/dist/sessionSyncFileHistoryCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectSessionSyncFileHistoryCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'sessionSyncFileHistory'))
+        return { kind: 'not_reported' };
+    const v = caps.sessionSyncFileHistory;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'sessionSyncFileHistory',
+    project: projectSessionSyncFileHistoryCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSessionSyncFileHistory(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSessionSyncFileHistory(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function sessionSyncFileHistoryAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+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)';
+        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';
+        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':
+            return 'session-sync file history on — syncing a session can also move its edited-file history';
+    }
+}
+export function forgetSessionSyncFileHistoryReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSessionSyncFileHistoryReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/skillToolListsCapability.d.ts

@@ -0,0 +1,18 @@
+export type SkillToolListsReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectSkillToolListsCapability(caps: unknown): SkillToolListsReading | undefined;
+export declare function noteEngineCapsForSkillToolLists(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedSkillToolLists(baseUrl?: string | undefined): SkillToolListsReading;
+export declare function skillToolListsAvailable(reading: SkillToolListsReading): 'yes' | 'no' | 'unknown';
+export declare function skillToolListsDoctorDetail(reading: SkillToolListsReading): string;
+export declare function forgetSkillToolListsReading(baseUrl: string | undefined): void;
+export declare function __resetSkillToolListsReadingsForTests(): void;

package/dist/skillToolListsCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectSkillToolListsCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'skillToolLists'))
+        return { kind: 'not_reported' };
+    const v = caps.skillToolLists;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'skillToolLists',
+    project: projectSkillToolListsCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSkillToolLists(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSkillToolLists(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function skillToolListsAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+        return 'no';
+    return 'unknown';
+}
+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)';
+        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':
+            return 'skill tool lists off on this deployment — tool lists on request skills are not read';
+        case 'present':
+            return 'skill tool lists on — a request skill’s allowed and disallowed tool lists are read as this run’s rules';
+    }
+}
+export function forgetSkillToolListsReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSkillToolListsReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/sqlEngineCapability.js

@@ -16,14 +16,7 @@ export function projectSqlEngineCapability(caps) {
             return { kind: 'none' };
         return projectSqlEngineView(nested);
     }
-    if (!Object.hasOwn(caps, 'sql'))
-        return { kind: 'not_reported' };
-    const sql = caps.sql;
-    if (sql === null)
-        return { kind: 'none' };
-    if (sql === undefined)
-        return { kind: 'not_reported' };
-    return projectSqlEngineView(sql);
+    return { kind: 'not_reported' };
 }
 function projectSqlEngineView(sql) {
     if (sql === null || typeof sql !== 'object')

package/dist/steerPriorityCapability.d.ts

@@ -0,0 +1,18 @@
+export type SteerPriorityReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    word: string;
+};
+export type SteerPriorityMode = 'engine' | 'advisory' | 'unknown';
+export declare function projectSteerPriorityCapability(caps: unknown): SteerPriorityReading | undefined;
+export declare function noteEngineCapsForSteerPriority(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedSteerPriority(baseUrl?: string | undefined): SteerPriorityReading;
+export declare function steerPriorityMode(reading: SteerPriorityReading): SteerPriorityMode;
+export declare function steerPriorityDoctorDetail(reading: SteerPriorityReading): string;
+export declare function forgetSteerPriorityReading(baseUrl: string | undefined): void;
+export declare function __resetSteerPriorityReadingsForTests(): void;

package/dist/steerPriorityCapability.js

@@ -0,0 +1,80 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectSteerPriorityCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'fleet'))
+        return { kind: 'not_reported' };
+    const fleet = caps.fleet;
+    if (fleet === undefined || fleet === false)
+        return { kind: 'not_reported' };
+    if (fleet === null || typeof fleet !== 'object' || Array.isArray(fleet))
+        return undefined;
+    if (!Object.hasOwn(fleet, 'steerPriority'))
+        return { kind: 'not_reported' };
+    const v = fleet.steerPriority;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'string' || v.length === 0)
+        return undefined;
+    return { kind: 'present', word: v };
+}
+const reader = createEngineCapReader({
+    name: 'fleet.steerPriority',
+    project: projectSteerPriorityCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSteerPriority(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSteerPriority(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function steerPriorityMode(reading) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return 'unknown';
+        if (!Object.hasOwn(reading, 'kind') || reading.kind !== 'present')
+            return 'unknown';
+        if (!Object.hasOwn(reading, 'word'))
+            return 'unknown';
+        const word = reading.word;
+        return word === 'engine' ? 'engine' : word === 'advisory' ? 'advisory' : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const WORD_DETAIL_MAX = 40;
+export function steerPriorityDoctorDetail(reading) {
+    const unobserved = 'steer priority not observed — the engine reports it on /v1/capabilities (fleet.steerPriority); this process has no usable capabilities reading cached for it, so a "now" or "later" steer is not sent';
+    let kind;
+    let word;
+    try {
+        if (reading === null || typeof reading !== 'object')
+            return unobserved;
+        kind = Object.hasOwn(reading, 'kind') ? reading.kind : undefined;
+        word = kind === 'present' && Object.hasOwn(reading, 'word') ? reading.word : undefined;
+    }
+    catch {
+        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)';
+    }
+    if (kind !== 'present' || typeof word !== 'string' || word.length === 0)
+        return unobserved;
+    if (word === 'engine')
+        return 'steer priority applied by the engine — "now" interrupts the running turn, "later" waits until the run would have stopped';
+    if (word === 'advisory') {
+        return 'steer priority accepted but not applied on this deployment — a "now" or "later" steer is not sent (steers without a priority work as before)';
+    }
+    return `steer priority reported as "${capForDisplay(word, WORD_DETAIL_MAX)}" — a value this client does not know yet, so whether it is applied is unknown and a "now" or "later" steer is not sent`;
+}
+export function forgetSteerPriorityReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSteerPriorityReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/steerReceipt.d.ts

@@ -0,0 +1,9 @@
+import type { SteerPriority } from '@sema-agent/sdk';
+export interface SteerReceiptReading {
+    readonly delivery: string | null;
+    readonly status: string | null;
+    readonly messageId?: string;
+    readonly priority?: SteerPriority;
+}
+export declare function ownNonEmptyStringOf(body: unknown, key: string): string | undefined;
+export declare function readSteerReceipt(receipt: unknown): SteerReceiptReading;

package/dist/steerReceipt.js

@@ -0,0 +1,25 @@
+export function ownNonEmptyStringOf(body, key) {
+    try {
+        if (typeof body !== 'object' || body === null || !Object.hasOwn(body, key))
+            return undefined;
+        const v = body[key];
+        return typeof v === 'string' && v.length > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function priorityEchoOf(body) {
+    const v = ownNonEmptyStringOf(body, 'priority');
+    return v === 'now' || v === 'next' || v === 'later' ? v : undefined;
+}
+export function readSteerReceipt(receipt) {
+    const messageId = ownNonEmptyStringOf(receipt, 'messageId');
+    const priority = priorityEchoOf(receipt);
+    return Object.freeze({
+        delivery: ownNonEmptyStringOf(receipt, 'delivery') ?? null,
+        status: ownNonEmptyStringOf(receipt, 'status') ?? null,
+        ...(messageId !== undefined ? { messageId } : {}),
+        ...(priority !== undefined ? { priority } : {}),
+    });
+}

package/dist/subagent/engineSubagentSteer.js

@@ -4,19 +4,12 @@ import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { errCodes, steeringRefusedBeforeEngine } from '../controlRouter.js';
+import { ownNonEmptyStringOf } from '../steerReceipt.js';
 function usableSteerClient(client) {
     return clientHasVerbs(client, [['runs', 'steerSubagent']]);
 }
 function steerReceiptMessageId(body) {
-    try {
-        if (typeof body !== 'object' || body === null || !Object.hasOwn(body, 'messageId'))
-            return undefined;
-        const v = body.messageId;
-        return typeof v === 'string' && v.length > 0 ? v : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    return ownNonEmptyStringOf(body, 'messageId');
 }
 export async function steerEngineSubagent(target, text, childTaskId, opts) {
     const named = typeof childTaskId === 'string' && childTaskId !== '' ? childTaskId : undefined;

package/dist/supportFloor.js

@@ -1,6 +1,6 @@
 export const SUPPORT_FLOOR = Object.freeze({
-    server: '7.104.0',
-    core: '7.33.8',
+    server: '7.106.0',
+    core: '7.35.2',
     sdk: '12.0.1',
 });
 export function supportFloorOf(component) {