@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/rewindWireCaps.js

@@ -1,7 +1,24 @@
-export function rewindSpecForMode(mode, targetEntryId) {
+function restoreFilesKeyMaySend(reading) {
+    if (reading === undefined)
+        return true;
+    try {
+        if (reading === null || typeof reading !== 'object')
+            return false;
+        const kind = reading.kind;
+        if (kind === 'unobserved')
+            return true;
+        return kind === 'present' && reading.restoreFilesEpoch === 'on';
+    }
+    catch {
+        return false;
+    }
+}
+export function rewindSpecForMode(mode, targetEntryId, reading) {
     switch (mode) {
         case 'both':
-            return { resumeAt: targetEntryId, resumeAtMode: 'before', restoreFiles: true };
+            return restoreFilesKeyMaySend(reading)
+                ? { resumeAt: targetEntryId, resumeAtMode: 'before', restoreFiles: true }
+                : { resumeAt: targetEntryId, resumeAtMode: 'before' };
         case 'conversation':
             return { resumeAt: targetEntryId, resumeAtMode: 'before' };
         case 'code':

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.d.ts

@@ -3,6 +3,7 @@ import type { EngineTurnUsage } from './adapter/downstream/turnUsageToModelUsage
 import type { RunCostReconcile } from './adapter/downstream/terminalToSdkResult.js';
 import type { WiringManifestAutoMode, WiringManifestModelGate, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, ContextUsageSectionView, PromptManifestSectionView, PromptManifestBlockView, PromptManifestToolView } from './adapter/downstream/eventToSdkMessage.js';
 import type { ToolRosterView, ToolRosterDeltaView, WiringManifestHandsView } from './toolRoster.js';
+import type { WiringManifestFleetView } from './adapter/downstream/wiringManifestView.js';
 import type { SuspendedReopenReading } from './hitl/suspendedReopen.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
@@ -177,6 +178,7 @@ export interface WiringManifestChromeEvent {
     instructions?: {
         readonly selected: readonly string[];
     };
+    fleet?: WiringManifestFleetView;
     eventId?: string;
 }
 export interface TextSegmentCommittedRow {

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) {

package/dist/taskRequestWords.d.ts

@@ -3,4 +3,10 @@ export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffor
 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"];
-export declare function retiredAttachmentsKeyWhy(nameOrToken: string, form?: 'token' | 'key'): string | undefined;
+export interface RetiredAttachmentsKey {
+    readonly key: string;
+    readonly why: string;
+    readonly because: string;
+    readonly remedy: string;
+}
+export declare function retiredAttachmentsKeyOf(nameOrToken: string, form?: 'token' | 'key'): RetiredAttachmentsKey | undefined;

package/dist/taskRequestWords.js

@@ -2,17 +2,27 @@ export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high'
 export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
 const _taskRequestWordPins = [true, true, true, true];
 void _taskRequestWordPins;
-export function retiredAttachmentsKeyWhy(nameOrToken, form = 'token') {
+export function retiredAttachmentsKeyOf(nameOrToken, form = 'token') {
     const lower = nameOrToken.trim().toLowerCase();
     const eq = lower.indexOf('=');
     const lhs = (eq < 0 ? lower : lower.slice(0, eq)).trim();
     const bare = lhs.startsWith('+') || lhs.startsWith('-') ? lhs.slice(1).trim() : lhs;
-    if (bare !== 'planmodereminder')
+    const retiredRows = [
+        {
+            key: 'planModeReminder',
+            since: 'core 7.39.0 / server 7.113.0',
+            because: 'the engine now states the plan posture itself whenever the permission mode is "plan"',
+            remedy: 'send permissionMode "plan" for the plan posture',
+        },
+    ];
+    const row = retiredRows.find((r) => r.key.toLowerCase() === bare);
+    if (row === undefined)
         return undefined;
-    const head = '"planModeReminder" was retired with core 7.39.0 / server 7.113.0 — the engine now states the plan posture itself whenever the permission mode is "plan"';
-    if (form === 'token')
-        return `${head}, and a request carrying the key is answered 400 request.field_invalid; remove the token (send permissionMode "plan" for the plan posture)`;
-    return nameOrToken === 'planModeReminder'
-        ? `${head}, and a request carrying this key is answered 400 request.field_invalid; remove the key (send permissionMode "plan" for the plan posture)`
-        : `${head}; the server ignores this spelling of it, but it is refused here so the retired key is not sent under any spelling; remove the key (send permissionMode "plan" for the plan posture)`;
+    const head = `"${row.key}" was retired with ${row.since} — ${row.because}`;
+    const why = form === 'token'
+        ? `${head}, and a request carrying the key is answered 400 request.field_invalid; remove the token (${row.remedy})`
+        : nameOrToken === row.key
+            ? `${head}, and a request carrying this key is answered 400 request.field_invalid; remove the key (${row.remedy})`
+            : `${head}; the server ignores this spelling of it, but it is refused here so the retired key is not sent under any spelling; remove the key (${row.remedy})`;
+    return { key: row.key, why, because: row.because, remedy: row.remedy };
 }

package/dist/toolHistoryBadTurn.d.ts

@@ -0,0 +1 @@
+export declare function toolHistoryBadTurnSentence(promptText: unknown): string;