@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/seatContract.js

@@ -1,7 +1,7 @@
 import { PERMISSION_MODE_WORDS, REASONING_EFFORT_WORDS } from "./taskRequestWords.js";
 import { liveDefaultModelCopy, liveModelRowCopy } from "./model/liveCatalogShape.js";
 import { REWIND_MODES } from "./rewindWireCaps.js";
-import { ownDataField, ownDataRefusalKeyOf, ownSendableField } from "./ownKey.js";
+import { guardedRead, ownDataField, ownDataRefusalKeyOf, ownSendableField, readOwnDataValue } from "./ownKey.js";
 const bad = (reason, field) => field === undefined ? { reason } : { reason, field };
 const nested = (prefix, verdict) => {
     const path = verdict.field === undefined
@@ -13,8 +13,15 @@ const nested = (prefix, verdict) => {
     return bad(reason, path);
 };
 const isObject = (v) => typeof v === "object" && v !== null;
+const isPlainRecord = (v) => {
+    if (!isObject(v) || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+};
 const isAbsent = (v) => typeof v === "undefined";
 const optionalString = (v) => isAbsent(v) || typeof v === "string";
+const isFolderPath = (v) => typeof v === "string" && v.length > 0;
 const inTuple = (tuple, v) => tuple.includes(v);
 const own = (o, k) => ownSendableField(o, k);
 const ownItems = (a) => {
@@ -112,14 +119,16 @@ const SEAT_EVENT_TYPE_TUPLE = [
     "error",
     "tool_permission_resolved",
 ];
-export const SEAT_EVENT_TYPES = SEAT_EVENT_TYPE_TUPLE;
+export const SEAT_EVENT_TYPES = Object.freeze(SEAT_EVENT_TYPE_TUPLE);
 const CHROME_EVENT_KIND_TUPLE = [
     "panel_task",
     "notification_terminal",
     "prompt_suggestions",
     "subagent_lifecycle",
+    "text_segment_end",
+    "thinking_segment_end",
 ];
-export const CHROME_EVENT_KINDS = CHROME_EVENT_KIND_TUPLE;
+export const CHROME_EVENT_KINDS = Object.freeze(CHROME_EVENT_KIND_TUPLE);
 const LANE_PROOF_LANE_TUPLE = ["main", "subagent", "workflow"];
 export const SEAT_CHROME_ENVELOPE_KEYS = ["kind", "laneProof"];
 export const HITL_RESOLUTION_OUTCOMES = [
@@ -132,7 +141,7 @@ export const HITL_RESOLUTION_OUTCOMES = [
     "decline",
     "cancel",
 ];
-export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -206,6 +215,7 @@ export function watchSeatCapability(store, name, onReading) {
 const SEAT_CAPABILITY_PHRASES = Object.freeze({
     pickFolder: Object.freeze({ action: "Opening a folder", ability: "show a folder picker", support: "folder picker support" }),
     rewind: Object.freeze({ action: "Rewinding to an earlier message", ability: "rewind this session", support: "rewind support" }),
+    recents: Object.freeze({ action: "Remembering recent folders", ability: "remember recent folders", support: "recent folders support" }), patchSession: Object.freeze({ action: "Renaming or pinning a conversation", ability: "rename or pin conversations", support: "rename and pin support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -228,6 +238,96 @@ export function seatCapabilityUnavailableDetail(name, reading) {
         return `${phrase.action} isn't available: this app hasn't reported ${phrase.support}.`;
     return `${phrase.action} isn't available: this app's support report couldn't be read.`;
 }
+const NO_TIME = Number.NEGATIVE_INFINITY;
+const stampMs = (v) => {
+    if (typeof v !== "string")
+        return NO_TIME;
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : NO_TIME;
+};
+const softField = (o, key) => typeof o === "object" && o !== null ? guardedRead(() => readOwnDataValue(o, key)) : undefined;
+const softItems = (a) => {
+    const isArray = guardedRead(() => Array.isArray(a));
+    if (isArray !== true)
+        return undefined;
+    const n = softField(a, "length");
+    if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < n; i += 1)
+        out.push(softField(a, String(i)));
+    return out;
+};
+export function recentFoldersOf(input) {
+    const sessions = softItems(softField(input, "sessions"));
+    const registered = softItems(softField(input, "registered"));
+    if (sessions === undefined && registered === undefined)
+        return null;
+    const byPath = new Map();
+    let order = 0;
+    const place = (path, at) => {
+        const cur = byPath.get(path);
+        order += 1;
+        if (cur === undefined)
+            byPath.set(path, { at, order });
+        else if (at > cur.at)
+            cur.at = at;
+    };
+    for (const row of registered ?? []) {
+        const path = softField(row, "path");
+        if (isFolderPath(path))
+            place(path, stampMs(softField(row, "lastUsedAt")));
+    }
+    for (const rec of sessions ?? []) {
+        const cwd = softField(rec, "cwd");
+        if (!isFolderPath(cwd))
+            continue;
+        const active = stampMs(softField(rec, "lastActivityAt"));
+        place(cwd, active !== NO_TIME ? active : stampMs(softField(rec, "createdAt")));
+    }
+    return [...byPath.entries()]
+        .sort(([, x], [, y]) => (x.at === y.at ? x.order - y.order : x.at > y.at ? -1 : 1))
+        .map(([path]) => path);
+}
+export async function readRecentFolders(input) {
+    const capability = guardedRead(() => input.capability);
+    const list = guardedRead(() => input.list);
+    const sessions = guardedRead(() => input.sessions);
+    let registered;
+    let host = "skipped";
+    let unreadableRows = 0;
+    if (capability !== undefined && seatCapabilityUnavailableDetail("recents", capability) === undefined) {
+        try {
+            const items = softItems(softField(await list(), "folders"));
+            if (items === undefined) {
+                host = "unreadable";
+            }
+            else {
+                const rows = [];
+                for (const item of items) {
+                    const path = softField(item, "path");
+                    if (!isFolderPath(path)) {
+                        unreadableRows += 1;
+                        continue;
+                    }
+                    const lastUsedAt = softField(item, "lastUsedAt");
+                    rows.push(typeof lastUsedAt === "string" ? { path, lastUsedAt } : { path });
+                }
+                if (items.length > 0 && rows.length === 0) {
+                    host = "unreadable";
+                }
+                else {
+                    registered = rows;
+                    host = "listed";
+                }
+            }
+        }
+        catch {
+            host = "unreadable";
+        }
+    }
+    return Object.freeze({ folders: recentFoldersOf({ sessions, registered }), host, unreadableRows });
+}
 export const PERMISSION_MODE_INTENTS = [...PERMISSION_MODE_WORDS];
 export const ATTACHMENT_IDS_PER_TASK_CAP = 16;
 export const SEAT_REASONING_EFFORTS = [...REASONING_EFFORT_WORDS];
@@ -241,6 +341,7 @@ export const SEAT_TURN_SETTINGS_ORIGINS = Object.freeze({
 });
 export const SEAT_REWIND_INTENT_KEYS = ["mode", "targetMessageUuid"];
 export const ATTACHMENT_UPLOAD_REQUEST_KEYS = ["name", "mimeType", "bytes"];
+export const SESSION_ROW_PATCH_REQUEST_KEYS = Object.freeze(["sessionId", "title", "pinned"]);
 export const SESSION_SEARCH_RESULT_KEYS = ["sessionId", "title", "matches"];
 export const GET_TRANSCRIPT_RESULT_KEYS = ["sessionId", "messages"];
 const checkLocalSessionRecord = seatCheck((s) => {
@@ -255,7 +356,7 @@ const checkLocalSessionRecord = seatCheck((s) => {
     if (!optionalString(own(s, "title")))
         return bad("title must be a string when present", "title");
     const cwd = own(s, "cwd");
-    if (!isAbsent(cwd) && (typeof cwd !== "string" || cwd.length === 0)) {
+    if (!isAbsent(cwd) && !isFolderPath(cwd)) {
         return bad("cwd must be a non-empty path string when present (absent = no folder chosen)", "cwd");
     }
     if (typeof own(s, "isRunning") !== "boolean")
@@ -274,6 +375,10 @@ const checkLocalSessionRecord = seatCheck((s) => {
     if (!isAbsent(parked) && typeof parked !== "boolean") {
         return bad("parked must be a boolean when present", "parked");
     }
+    const pinned = own(s, "pinned");
+    if (!isAbsent(pinned) && typeof pinned !== "boolean") {
+        return bad("pinned must be a boolean when present (absent = not pinned or unknown)", "pinned");
+    }
     return true;
 });
 export function isLocalSessionRecord(s) {
@@ -597,6 +702,30 @@ export function checkSendMessageRequest(v) {
 export function isSendMessageRequest(v) {
     return checkSendMessageRequest(v) === true;
 }
+export const checkSessionRowPatchRequest = seatCheck((v) => {
+    if (!isObject(v) || Array.isArray(v))
+        return bad("patchSession request is not an object");
+    const body = {};
+    for (const k of Object.keys(v)) {
+        if (!inTuple(SESSION_ROW_PATCH_REQUEST_KEYS, k))
+            return bad(`unknown key (closed shape: ${SESSION_ROW_PATCH_REQUEST_KEYS.join(", ")})`, k);
+        body[k] = own(v, k);
+    }
+    if (typeof body.sessionId !== "string" || body.sessionId.length === 0)
+        return bad("sessionId must be a non-empty string", "sessionId");
+    const { title, pinned } = body;
+    if (!isAbsent(title) && title !== null && (typeof title !== "string" || title.length === 0)) {
+        return bad('title must be a non-empty string, or null to clear it back to the automatic title (an empty string is not a way to clear)', "title");
+    }
+    if (!isAbsent(pinned) && typeof pinned !== "boolean")
+        return bad("pinned must be a boolean when present", "pinned");
+    if (isAbsent(title) && isAbsent(pinned))
+        return bad("nothing to change: carry at least one of title / pinned");
+    return true;
+});
+export function isSessionRowPatchRequest(v) {
+    return checkSessionRowPatchRequest(v) === true;
+}
 const checkSendMessageAck = seatCheck((v) => {
     if (!isObject(v))
         return bad("sendMessage ack is not an object");
@@ -678,11 +807,10 @@ const checkFocusedSessionState = seatCheck((v) => {
     return true;
 });
 const checkSettingsState = seatCheck((v) => {
-    if (!isObject(v))
-        return bad("settings state is not an object");
-    const defaultModel = own(v, "defaultModel");
-    if (defaultModel !== null && typeof defaultModel !== "string") {
-        return bad("defaultModel must be a string or null", "defaultModel");
+    if (!isPlainRecord(v))
+        return bad("settings state is not a plain object");
+    if (Object.hasOwn(v, "defaultModel")) {
+        return bad("defaultModel is not carried in settings state: read the deployment default model from the model catalog (liveDefaultModelOf over the listModels() result)", "defaultModel");
     }
     if (!optionalString(own(v, "engineVersion")))
         return bad("engineVersion must be a string when present", "engineVersion");
@@ -690,9 +818,32 @@ const checkSettingsState = seatCheck((v) => {
         return bad("dataRoot must be a string when present", "dataRoot");
     return true;
 });
-const checkPickFolderResult = (v) => v === null || (typeof v === "string" && v.length > 0)
+const checkPickFolderResult = (v) => v === null || isFolderPath(v)
     ? true
     : bad("pickFolder result must be null (cancelled) or a non-empty path string");
+const checkRecentFolderRow = seatCheck((v) => {
+    if (!isPlainRecord(v))
+        return bad("recent folder row is not a plain object");
+    if (!isFolderPath(own(v, "path")))
+        return bad("path must be a non-empty path string", "path");
+    if (!optionalString(own(v, "lastUsedAt")))
+        return bad("lastUsedAt must be a string when present", "lastUsedAt");
+    return true;
+});
+const checkRecentFoldersResult = seatCheck((v) => {
+    if (!isPlainRecord(v))
+        return bad("recent folders result is not a plain object");
+    const folders = own(v, "folders");
+    if (!Array.isArray(folders))
+        return bad("folders must be an array", "folders");
+    const rows = ownItems(folders);
+    for (let i = 0; i < rows.length; i += 1) {
+        const verdict = checkRecentFolderRow(rows[i]);
+        if (verdict !== true)
+            return nested(`folders[${i}]`, verdict);
+    }
+    return true;
+});
 const checkSeatCapabilitiesState = seatCheck((v) => {
     if (!isObject(v) || Array.isArray(v))
         return bad("seat capabilities state is not an object");
@@ -730,6 +881,8 @@ export const LOCAL_SESSIONS_SPEC = {
         listModels: { kind: "invoke", check: checkLiveModelCatalog },
         applyModelConfig: { kind: "invoke", check: checkApplyModelConfigResult },
         pickFolder: { kind: "invoke", check: checkPickFolderResult },
+        listRecentFolders: { kind: "invoke", check: checkRecentFoldersResult },
+        noteRecentFolder: { kind: "invoke", check: checkOkAck }, patchSession: { kind: "invoke", check: checkLocalSessionRecord },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
     },
@@ -757,6 +910,8 @@ export const SEAT_METHOD_NAMES = [
     "listModels",
     "applyModelConfig",
     "pickFolder",
+    "listRecentFolders",
+    "noteRecentFolder", "patchSession",
     "onEvent",
     "onToolPermissionRequest",
 ];
@@ -804,6 +959,7 @@ export const TOOL_PERMISSION_REQUEST_KEYS = [
     "ruleOffersAbsence",
     "askClass",
     "classes",
+    "rememberRefused",
 ];
 export const LOCAL_SESSION_RECORD_KEYS = [
     "sessionId",
@@ -816,6 +972,7 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "lastActivityAt",
     "queuedMessages",
     "parked",
+    "pinned",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
     "sessionId",
@@ -860,7 +1017,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     LocalSessionRecord: {
         guard: "isLocalSessionRecord",
         check: checkLocalSessionRecord,
-        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked"],
+        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned"],
         unchecked: [],
     },
     ToolPermissionRequest: {
@@ -900,6 +1057,10 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "classes",
                 why: "与 askClass 同一对(CC-284),同在同缺、同一只成对窄读(非空、每员非空串、无重复、首员等于 askClass;开集、原样顺序);座位门不设第二判官,理由同 askClass。",
             },
+            {
+                key: "rememberRefused",
+                why: "展示增强位(CC-642),权威窄读在卡口两条腿与过境口 toolPermissionRequestAskBits(同一只 readApprovalRememberRefused:自有键 ∧ 严格 true 才上座,永不铸 false);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。消费端 `=== true` 读,其余(缺席 / 坏形)一律当缺席 ⇒ 照旧渲「本会话放行」。缺席 = 服务端没说(记得住或老服务端),不是 false。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
             {
                 key: "ruleOffersAbsence",
                 why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
@@ -971,6 +1132,12 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         ],
         unchecked: [],
     },
+    SessionRowPatchRequest: {
+        guard: "isSessionRowPatchRequest",
+        check: checkSessionRowPatchRequest,
+        validated: ["sessionId", "title", "pinned"],
+        unchecked: [],
+    },
     ApplyModelConfigResult: {
         check: checkApplyModelConfigResult,
         validated: ["ok", "requiresRestart", "reason"],
@@ -1019,12 +1186,22 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SettingsState: {
         check: checkSettingsState,
-        validated: ["defaultModel", "engineVersion", "dataRoot"],
+        validated: ["engineVersion", "dataRoot"],
         unchecked: [],
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession"],
+        unchecked: [],
+    },
+    RecentFoldersResult: {
+        check: checkRecentFoldersResult,
+        validated: ["folders"],
+        unchecked: [],
+    },
+    RecentFolderRow: {
+        check: checkRecentFolderRow,
+        validated: ["path", "lastUsedAt"],
         unchecked: [],
     },
     SeatRewindIntent: {
@@ -1087,5 +1264,9 @@ const _seatContractPins = [
     true, true, true, true, true, true, true, true,
     true, true, true, true, true,
     true, true, true, true, true, true, true, true,
+    true, true,
+    true, true,
+    true, true, true, true,
+    true, true, true, true, true, true,
 ];
 void _seatContractPins;

package/dist/sessionReadRedactionCapability.d.ts

@@ -7,9 +7,5 @@ export type SessionReadRedactionReading = {
     value: true;
 };
 export declare function projectSessionReadRedactionCapability(caps: unknown): SessionReadRedactionReading | undefined;
-export declare function noteEngineCapsForSessionReadRedaction(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedSessionReadRedaction(baseUrl?: string | undefined): SessionReadRedactionReading;
 export declare function sessionReadRedactionAdmitted(reading: SessionReadRedactionReading | undefined): boolean;
-export declare function __resetSessionReadRedactionReadingsForTests(): void;

package/dist/sessionReadRedactionCapability.js

@@ -19,9 +19,6 @@ const reader = createEngineCapReader({
     project: projectSessionReadRedactionCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForSessionReadRedaction(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedSessionReadRedaction(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -37,6 +34,3 @@ export function sessionReadRedactionAdmitted(reading) {
         return false;
     }
 }
-export function __resetSessionReadRedactionReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/sessionSyncFileHistory.d.ts

@@ -0,0 +1,4 @@
+export declare const FILE_HISTORY_SKIPPED_NOTICE: string;
+export declare function fileHistorySyncNotice(result: unknown): string | undefined;
+export declare function fileHistorySyncNoticeIdentity(result: unknown): string | undefined;
+export declare function isFileHistoryBlobMissing(err: unknown): boolean;

package/dist/sessionSyncFileHistory.js

@@ -0,0 +1,66 @@
+import { NOT_FOUND_BLOB } from './engineErrorCodes.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+import { readThrownSlot } from './wireFailureShape.js';
+export const FILE_HISTORY_SKIPPED_NOTICE = 'File history was not copied: only the conversation was synced, because one of the two engines does not confirm that it can ' +
+    'transfer file history (the record /rewind uses to restore files). Syncing this session again will not add it until ' +
+    'the conversation has new turns and both engines can transfer file history.';
+function getOwn(o, key) {
+    return Object.hasOwn(o, key) ? o[key] : undefined;
+}
+function envelopeSaidEmpty(result) {
+    try {
+        const manifest = getOwn(result, 'manifest');
+        if (manifest === null || typeof manifest !== 'object')
+            return false;
+        const fh = getOwn(manifest, 'fileHistory');
+        if (fh === null || typeof fh !== 'object')
+            return false;
+        const tracked = getOwn(fh, 'tracked');
+        const boundaries = getOwn(fh, 'boundaries');
+        return Array.isArray(tracked) && tracked.length === 0 && Array.isArray(boundaries) && boundaries.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function fileHistorySyncNotice(result) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    try {
+        if (getOwn(result, 'fileHistory') !== 'skipped')
+            return undefined;
+        return envelopeSaidEmpty(result) ? undefined : FILE_HISTORY_SKIPPED_NOTICE;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function fileHistorySyncNoticeIdentity(result) {
+    if (fileHistorySyncNotice(result) === undefined)
+        return undefined;
+    try {
+        const manifest = getOwn(result, 'manifest');
+        if (manifest === null || typeof manifest !== 'object')
+            return undefined;
+        const sessionId = getOwn(manifest, 'sessionId');
+        const leafId = getOwn(manifest, 'leafId');
+        if (typeof sessionId !== 'string' || sessionId === '' || typeof leafId !== 'string' || leafId === '')
+            return undefined;
+        return JSON.stringify([sessionId, leafId]);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isFileHistoryBlobMissing(err) {
+    if (typeof err !== 'object' || err === null)
+        return false;
+    try {
+        if (readThrownSlot(err, 'status') !== 404)
+            return false;
+        return effectiveWireErrorCode(err) === NOT_FOUND_BLOB;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sessionSyncFileHistoryCapability.d.ts

@@ -14,4 +14,3 @@ export declare function noteEngineCapsForSessionSyncFileHistory(baseUrl: string,
 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 __resetSessionSyncFileHistoryReadingsForTests(): void;

package/dist/sessionSyncFileHistoryCapability.js

@@ -46,6 +46,3 @@ export function sessionSyncFileHistoryDoctorDetail(reading) {
             return 'session-sync file history on — syncing a session can also move its edited-file history';
     }
 }
-export function __resetSessionSyncFileHistoryReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/skillToolListsCapability.d.ts

@@ -14,4 +14,3 @@ export declare function noteEngineCapsForSkillToolLists(baseUrl: string, caps: u
 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 __resetSkillToolListsReadingsForTests(): void;

package/dist/skillToolListsCapability.js

@@ -46,6 +46,3 @@ export function skillToolListsDoctorDetail(reading) {
             return 'skill tool lists on — a request skill’s allowed and disallowed tool lists are read as this run’s rules';
     }
 }
-export function __resetSkillToolListsReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/steerPriorityCapability.d.ts

@@ -14,4 +14,3 @@ export declare function noteEngineCapsForSteerPriority(baseUrl: string, caps: un
 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 __resetSteerPriorityReadingsForTests(): void;

package/dist/steerPriorityCapability.js

@@ -74,6 +74,3 @@ export function steerPriorityDoctorDetail(reading) {
     }
     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 __resetSteerPriorityReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/storePostureCapability.d.ts

@@ -15,11 +15,7 @@ export type StorePostureReading = {
     view: StorePostureView;
 };
 export declare function projectStorePostureCapability(caps: unknown): StorePostureReading | undefined;
-export declare function noteEngineCapsForStorePosture(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedStorePosture(baseUrl?: string | undefined): StorePostureReading;
 export declare function storePersistence(reading: StorePostureReading): 'durable' | 'not_durable' | 'unknown';
 export declare function storePostureHeadWord(reading: StorePostureReading): string | undefined;
 export declare function storePostureDoctorDetail(reading: StorePostureReading): string;
-export declare function __resetStorePostureReadingsForTests(): void;

package/dist/storePostureCapability.js

@@ -46,9 +46,6 @@ const reader = createEngineCapReader({
     project: projectStorePostureCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForStorePosture(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -127,6 +124,3 @@ export function storePostureDoctorDetail(reading) {
     }
     return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
 }
-export function __resetStorePostureReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/subagent/engineSubagentSteer.js

@@ -5,6 +5,7 @@ import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.j
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { errCodes, steeringRefusedBeforeEngine } from '../controlRouter.js';
 import { ownNonEmptyStringOf } from '../steerReceipt.js';
+import { wireFailureTextsOf } from '../wireFailureShape.js';
 function usableSteerClient(client) {
     return clientHasVerbs(client, [['runs', 'steerSubagent']]);
 }
@@ -53,14 +54,14 @@ export async function steerEngineSubagent(target, text, childTaskId, opts) {
             status = undefined;
         }
         if (status !== undefined) {
-            const detail = e instanceof Error ? e.message : String(e);
-            hostLog('debug', `engineSubagentSteer: ${status} ${detail.slice(0, 200)}`);
+            const texts = wireFailureTextsOf(e);
+            hostLog('debug', `engineSubagentSteer: ${status} ${texts.log.slice(0, 200)}`);
             const refused = typeof e === 'object' && e !== null ? steeringRefusedBeforeEngine(e) : undefined;
             if (refused !== undefined && refused.safety === 'ledger_unavailable') {
                 return { ok: false, reason: 'not-delivered', safety: refused.safety, detail: refused.advice };
             }
             if (status === 409 || status === 404) {
-                return { ok: false, reason: 'not-running', detail };
+                return { ok: false, reason: 'not-running', detail: texts.reason };
             }
             return { ok: false, reason: 'error', detail: `${status}` };
         }
@@ -69,7 +70,8 @@ export async function steerEngineSubagent(target, text, childTaskId, opts) {
             hostLog('debug', `engineSubagentSteer: may have been received, no answer — ${noAnswer}`);
             return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
         }
-        hostLog('debug', `engineSubagentSteer: fetch failed ${String(e)}`);
-        return { ok: false, reason: 'error', detail: String(e) };
+        const texts = wireFailureTextsOf(e);
+        hostLog('debug', `engineSubagentSteer: fetch failed ${texts.log}`);
+        return { ok: false, reason: 'error', detail: texts.reason };
     }
 }

package/dist/subagentContentStore.js

@@ -1,22 +1,11 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
+import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     if (v === undefined || v === null)
         return undefined;
-    if (typeof v === 'string')
-        return v;
-    if (Array.isArray(v)) {
-        const parts = [];
-        for (const block of v) {
-            if (block && typeof block === 'object') {
-                const b = block;
-                if (b.type === 'text' && typeof b.text === 'string')
-                    parts.push(b.text);
-                else if (b.type === 'image')
-                    parts.push('[image]');
-            }
-        }
-        return parts.join('');
-    }
+    const text = toolEndOutputText(v);
+    if (text !== undefined)
+        return text;
     try {
         return JSON.stringify(v);
     }

package/dist/supportFloor.d.ts

@@ -8,4 +8,5 @@ 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 engineSupportFloorEffective(floor?: string): string;
 export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;