@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/seatContract.js

@@ -1,4 +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 { 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
@@ -10,9 +13,73 @@ 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) => {
+    const n = ownDataField(a, "length");
+    const out = [];
+    if (typeof n !== "number")
+        return out;
+    for (let i = 0; i < n; i += 1)
+        out.push(own(a, String(i)));
+    return out;
+};
+const firstAccessorPath = (root) => {
+    const seen = new Set();
+    const stack = [[root, ""]];
+    while (stack.length > 0) {
+        const [v, path] = stack.pop();
+        if (typeof v !== "object" || v === null || seen.has(v))
+            continue;
+        seen.add(v);
+        for (const k of Reflect.ownKeys(v)) {
+            if (typeof k !== "string")
+                continue;
+            const d = Reflect.getOwnPropertyDescriptor(v, k);
+            if (d === undefined)
+                continue;
+            const at = path === "" ? k : `${path}.${k}`;
+            if (!Object.hasOwn(d, "value"))
+                return at;
+            stack.push([d.value, at]);
+        }
+    }
+    return undefined;
+};
+const NOT_PLAIN_DATA = "must be a plain enumerable data property (accessors are refused and never executed)";
+const seatCheck = (fn) => (v) => {
+    try {
+        const at = firstAccessorPath(v);
+        if (at !== undefined)
+            return bad(NOT_PLAIN_DATA, at);
+        return fn(v);
+    }
+    catch (e) {
+        const key = ownDataRefusalKeyOf(e);
+        return key !== undefined ? bad(NOT_PLAIN_DATA, key) : bad("payload could not be read");
+    }
+};
+const seatCheckAt = (fn) => (v, field) => {
+    try {
+        const at = firstAccessorPath(v);
+        if (at !== undefined)
+            return bad(NOT_PLAIN_DATA, `${field}.${at}`);
+        return fn(v, field);
+    }
+    catch (e) {
+        const key = ownDataRefusalKeyOf(e);
+        return key !== undefined ? bad(NOT_PLAIN_DATA, `${field}.${key}`) : bad("payload could not be read", field);
+    }
+};
 export const TOOL_PERMISSION_REQUEST_ID_DOMAINS = Object.freeze([
     "live:",
     "durable:",
@@ -52,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 = [
@@ -72,7 +141,7 @@ export const HITL_RESOLUTION_OUTCOMES = [
     "decline",
     "cancel",
 ];
-export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder"]);
+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 });
@@ -145,6 +214,8 @@ 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)
@@ -167,355 +238,629 @@ 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];
 export const SEAT_TURN_SETTINGS_KEYS = ["ultracode"];
+export const SEAT_TURN_SETTINGS_ORIGINS = Object.freeze({
+    ultracode: Object.freeze({ carriedBy: "renderer" }),
+    webSearch: Object.freeze({ hostSupplied: "联网检索的每请求配置来自宿主的设置源(可能带检索服务的凭据与私网地址);渲染端没有设置文件,也不该持有凭据" }),
+    hooks: Object.freeze({ hostSupplied: "hooks 表来自宿主的设置文件(宿主经设置端口与 hooksForWire 投影);渲染端没有设置文件、也不执行本机 hook" }),
+    resolved: Object.freeze({ hostSupplied: "设置解析器的生效快照(hooks / env / model / 已解析权限)由宿主跑解析器得出;渲染端没有设置源可解析" }),
+    outputStyle: Object.freeze({ hostSupplied: "输出风格正文由宿主的兜底层随请求带(风格文件在宿主);渲染端只选名字,不持正文" }),
+});
+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 = (s) => {
+const checkLocalSessionRecord = seatCheck((s) => {
     if (!isObject(s))
         return bad("session record is not an object");
-    if (typeof s.sessionId !== "string")
+    if (typeof own(s, "sessionId") !== "string")
         return bad("sessionId must be a string", "sessionId");
-    if (!optionalString(s.engineSessionId))
+    if (!optionalString(own(s, "engineSessionId")))
         return bad("engineSessionId must be a string when present", "engineSessionId");
-    if (!optionalString(s.model))
+    if (!optionalString(own(s, "model")))
         return bad("model must be a string when present", "model");
-    if (!optionalString(s.title))
+    if (!optionalString(own(s, "title")))
         return bad("title must be a string when present", "title");
-    if (!isAbsent(s.cwd) && (typeof s.cwd !== "string" || s.cwd.length === 0)) {
+    const cwd = own(s, "cwd");
+    if (!isAbsent(cwd) && !isFolderPath(cwd)) {
         return bad("cwd must be a non-empty path string when present (absent = no folder chosen)", "cwd");
     }
-    if (typeof s.isRunning !== "boolean")
+    if (typeof own(s, "isRunning") !== "boolean")
         return bad("isRunning must be a boolean", "isRunning");
-    if (typeof s.createdAt !== "string")
+    if (typeof own(s, "createdAt") !== "string")
         return bad("createdAt must be an ISO-8601 string", "createdAt");
-    if (!optionalString(s.lastActivityAt))
+    if (!optionalString(own(s, "lastActivityAt")))
         return bad("lastActivityAt must be a string when present", "lastActivityAt");
-    if (!isAbsent(s.queuedMessages)) {
-        const q = s.queuedMessages;
-        const okQueue = Array.isArray(q) && q.every((row) => isObject(row) && typeof row.uuid === "string" && typeof row.text === "string");
+    const q = own(s, "queuedMessages");
+    if (!isAbsent(q)) {
+        const okQueue = Array.isArray(q) && ownItems(q).every((row) => isObject(row) && typeof own(row, "uuid") === "string" && typeof own(row, "text") === "string");
         if (!okQueue)
             return bad("queuedMessages must be an array of {uuid,text}", "queuedMessages");
     }
-    if (!isAbsent(s.parked) && typeof s.parked !== "boolean") {
+    const parked = own(s, "parked");
+    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) {
     return checkLocalSessionRecord(s) === true;
 }
-const checkToctouBinding = (v) => {
+const checkToctouBinding = seatCheck((v) => {
     if (!isObject(v))
         return bad("toctouBinding must be an object", "toctouBinding");
-    if (typeof v.callId !== "string")
+    if (typeof own(v, "callId") !== "string")
         return bad("toctouBinding.callId must be a string", "toctouBinding.callId");
-    if (typeof v.inputHash !== "string")
+    if (typeof own(v, "inputHash") !== "string")
         return bad("toctouBinding.inputHash must be a string", "toctouBinding.inputHash");
     return true;
-};
-const checkToolPermissionRequest = (r) => {
+});
+const checkToolPermissionRequest = seatCheck((r) => {
     if (!isObject(r))
         return bad("tool permission request is not an object");
-    if (typeof r.requestId !== "string")
+    const requestId = own(r, "requestId");
+    if (typeof requestId !== "string")
         return bad("requestId must be a string", "requestId");
-    if (toolPermissionRequestIdDomain(r.requestId) === undefined) {
+    if (toolPermissionRequestIdDomain(requestId) === undefined) {
         return bad(`requestId must carry a registered domain prefix (${TOOL_PERMISSION_REQUEST_ID_DOMAINS.join("|")})`, "requestId");
     }
-    if (typeof r.sessionId !== "string")
+    if (typeof own(r, "sessionId") !== "string")
         return bad("sessionId must be a string", "sessionId");
-    if (!isAbsent(r.toolName) && r.toolName !== null && typeof r.toolName !== "string") {
+    const toolName = own(r, "toolName");
+    if (!isAbsent(toolName) && toolName !== null && typeof toolName !== "string") {
         return bad("toolName must be a string or null when present", "toolName");
     }
-    if (!isAbsent(r.toolCallId) && r.toolCallId !== null && typeof r.toolCallId !== "string") {
+    const toolCallId = own(r, "toolCallId");
+    if (!isAbsent(toolCallId) && toolCallId !== null && typeof toolCallId !== "string") {
         return bad("toolCallId must be a string or null when present", "toolCallId");
     }
-    if (!optionalString(r.message))
+    if (!optionalString(own(r, "message")))
         return bad("message must be a string when present", "message");
-    if (!isAbsent(r.toctouBinding)) {
-        const verdict = checkToctouBinding(r.toctouBinding);
+    const toctouBinding = own(r, "toctouBinding");
+    if (!isAbsent(toctouBinding)) {
+        const verdict = checkToctouBinding(toctouBinding);
         if (verdict !== true)
             return verdict;
     }
-    if (!isAbsent(r.createdAtMs) && typeof r.createdAtMs !== "number") {
+    const createdAtMs = own(r, "createdAtMs");
+    if (!isAbsent(createdAtMs) && typeof createdAtMs !== "number") {
         return bad("createdAtMs must be a number (epoch ms) when present", "createdAtMs");
     }
     return true;
-};
+});
 export function isToolPermissionRequest(r) {
     return checkToolPermissionRequest(r) === true;
 }
-const checkLaneProof = (v, field) => {
+const checkLaneProof = seatCheckAt((v, field) => {
     if (!isObject(v))
         return bad("laneProof must be an object", field);
-    const lane = v.lane;
+    const lane = own(v, "lane");
     if (typeof lane !== "string" || !inTuple(LANE_PROOF_LANE_TUPLE, lane)) {
         return bad(`laneProof.lane must be one of ${LANE_PROOF_LANE_TUPLE.join("|")}`, `${field}.lane`);
     }
-    if (lane === "subagent" && typeof v.parentToolCallId !== "string") {
+    if (lane === "subagent" && typeof own(v, "parentToolCallId") !== "string") {
         return bad("subagent laneProof needs parentToolCallId", `${field}.parentToolCallId`);
     }
-    if (lane === "workflow" && (typeof v.via !== "string" || typeof v.key !== "string")) {
+    if (lane === "workflow" && (typeof own(v, "via") !== "string" || typeof own(v, "key") !== "string")) {
         return bad("workflow laneProof needs via + key", `${field}.via`);
     }
     return true;
-};
-const checkSeatChromeEnvelope = (v, field) => {
+});
+const checkSeatChromeEnvelope = seatCheckAt((v, field) => {
     if (!isObject(v))
         return bad("chrome must be an object", field);
-    const kind = v.kind;
+    const kind = own(v, "kind");
     if (typeof kind !== "string")
         return bad("chrome.kind must be a string", `${field}.kind`);
     if (!inTuple(CHROME_EVENT_KIND_TUPLE, kind)) {
         return bad(`chrome.kind is not a renderer-wired arm (${CHROME_EVENT_KIND_TUPLE.join("|")})`, `${field}.kind`);
     }
-    return checkLaneProof(v.laneProof, `${field}.laneProof`);
-};
-const checkLocalSessionEvent = (v) => {
+    return checkLaneProof(own(v, "laneProof"), `${field}.laneProof`);
+});
+const checkLocalSessionEvent = seatCheck((v) => {
     if (!isObject(v))
         return bad("event is not an object");
-    const type = v.type;
+    const type = own(v, "type");
     if (typeof type !== "string")
         return bad("type must be a string", "type");
     if (!inTuple(SEAT_EVENT_TYPE_TUPLE, type)) {
         return bad(`type is not a registered seat event name (${SEAT_EVENT_TYPE_TUPLE.join("|")})`, "type");
     }
-    if (typeof v.sessionId !== "string")
+    if (typeof own(v, "sessionId") !== "string")
         return bad("sessionId must be a string", "sessionId");
-    if (!isAbsent(v.messages) && !Array.isArray(v.messages))
+    const messages = own(v, "messages");
+    if (!isAbsent(messages) && !Array.isArray(messages))
         return bad("messages must be an array", "messages");
-    if (!optionalString(v.error))
+    if (!optionalString(own(v, "error")))
         return bad("error must be a string when present", "error");
-    if (!optionalString(v.errorCategory))
+    if (!optionalString(own(v, "errorCategory")))
         return bad("errorCategory must be a string when present", "errorCategory");
-    if (!isAbsent(v.code) && typeof v.code !== "number")
+    const code = own(v, "code");
+    if (!isAbsent(code) && typeof code !== "number")
         return bad("code must be a number when present", "code");
-    if (!isAbsent(v.request)) {
-        const verdict = checkToolPermissionRequest(v.request);
+    const request = own(v, "request");
+    if (!isAbsent(request)) {
+        const verdict = checkToolPermissionRequest(request);
         if (verdict !== true)
             return nested("request", verdict);
     }
-    if (!optionalString(v.data))
+    if (!optionalString(own(v, "data")))
         return bad("data must be a string when present", "data");
-    if (!isAbsent(v.sources)) {
-        const okSources = Array.isArray(v.sources) && v.sources.every((t) => typeof t === "string");
+    const sources = own(v, "sources");
+    if (!isAbsent(sources)) {
+        const okSources = Array.isArray(sources) && ownItems(sources).every((t) => typeof t === "string");
         if (!okSources)
             return bad("sources must be a string[]", "sources");
     }
-    if (!isAbsent(v.permissionMode)) {
-        const mode = v.permissionMode;
+    const mode = own(v, "permissionMode");
+    if (!isAbsent(mode)) {
         if (typeof mode !== "string" || !inTuple(PERMISSION_MODE_INTENTS, mode)) {
             return bad(`permissionMode must be one of ${PERMISSION_MODE_INTENTS.join("|")}`, "permissionMode");
         }
     }
-    if (!isAbsent(v.session)) {
-        const verdict = checkLocalSessionRecord(v.session);
+    const session = own(v, "session");
+    if (!isAbsent(session)) {
+        const verdict = checkLocalSessionRecord(session);
         if (verdict !== true)
             return nested("session", verdict);
     }
-    if (!optionalString(v.userMessageUuid))
+    if (!optionalString(own(v, "userMessageUuid")))
         return bad("userMessageUuid must be a string when present", "userMessageUuid");
-    if (!isAbsent(v.hasPreClearSession) && typeof v.hasPreClearSession !== "boolean") {
+    const hasPreClearSession = own(v, "hasPreClearSession");
+    if (!isAbsent(hasPreClearSession) && typeof hasPreClearSession !== "boolean") {
         return bad("hasPreClearSession must be a boolean when present", "hasPreClearSession");
     }
-    if (!optionalString(v.requestId))
+    if (!optionalString(own(v, "requestId")))
         return bad("requestId must be a string when present", "requestId");
-    if (!optionalString(v.outcome))
+    const outcome = own(v, "outcome");
+    if (!optionalString(outcome))
         return bad("outcome must be a string when present", "outcome");
-    if (!isAbsent(v.chrome)) {
-        const verdict = checkSeatChromeEnvelope(v.chrome, "chrome");
+    const parked = own(v, "parked");
+    if (!isAbsent(parked)) {
+        if (parked !== true)
+            return bad("parked must be the literal true when present (absent = no park evidence)", "parked");
+        if (type !== "tool_permission_resolved" || outcome !== "expired") {
+            return bad('parked is only allowed on a tool_permission_resolved event whose outcome is "expired"', "parked");
+        }
+    }
+    const chrome = own(v, "chrome");
+    if (!isAbsent(chrome)) {
+        const verdict = checkSeatChromeEnvelope(chrome, "chrome");
         if (verdict !== true)
             return nested("chrome", verdict);
     }
     return true;
-};
+});
 export function isLocalSessionEvent(v) {
     return checkLocalSessionEvent(v) === true;
 }
-const checkAttachmentUploadReceipt = (v) => {
+const checkAttachmentUploadReceipt = seatCheck((v) => {
     if (!isObject(v))
         return bad("upload receipt is not an object");
-    if (typeof v.id !== "string")
+    if (typeof own(v, "id") !== "string")
         return bad("id must be a string", "id");
-    if (typeof v.name !== "string")
+    if (typeof own(v, "name") !== "string")
         return bad("name must be a string", "name");
-    if (typeof v.mime !== "string")
+    if (typeof own(v, "mime") !== "string")
         return bad("mime must be a string", "mime");
-    if (typeof v.sha256 !== "string")
+    if (typeof own(v, "sha256") !== "string")
         return bad("sha256 must be a string", "sha256");
-    if (typeof v.sizeBytes !== "number")
+    if (typeof own(v, "sizeBytes") !== "number")
         return bad("sizeBytes must be a number", "sizeBytes");
     return true;
-};
+});
 export function isAttachmentUploadReceipt(v) {
     return checkAttachmentUploadReceipt(v) === true;
 }
-const checkSeatModelInfo = (m, index) => {
-    if (!isObject(m))
-        return bad(`models[${index}] is not an object`, "models");
-    if (typeof m.id !== "string")
-        return bad(`models[${index}].id must be a string`, "models");
-    if (!optionalString(m.name))
-        return bad(`models[${index}].name must be a string when present`, "models");
-    if (!optionalString(m.provider))
-        return bad(`models[${index}].provider must be a string when present`, "models");
-    if (!isAbsent(m.contextWindow) && typeof m.contextWindow !== "number") {
-        return bad(`models[${index}].contextWindow must be a number when present`, "models");
-    }
-    if (!isAbsent(m.maxOutputTokens) && typeof m.maxOutputTokens !== "number") {
-        return bad(`models[${index}].maxOutputTokens must be a number when present`, "models");
-    }
-    return true;
-};
-const checkApplyModelConfigResult = (v) => {
+const checkApplyModelConfigResult = seatCheck((v) => {
     if (!isObject(v))
         return bad("applyModelConfig result is not an object");
-    if (typeof v.ok !== "boolean")
+    const ok = own(v, "ok");
+    if (typeof ok !== "boolean")
         return bad("ok must be a boolean", "ok");
-    if (typeof v.requiresRestart !== "boolean")
+    if (typeof own(v, "requiresRestart") !== "boolean")
         return bad("requiresRestart must be a boolean", "requiresRestart");
-    if (v.ok === false && (typeof v.reason !== "string" || v.reason.length === 0)) {
+    const reason = own(v, "reason");
+    if (ok === false && (typeof reason !== "string" || reason.length === 0)) {
         return bad("reason must be a non-empty string when ok is false", "reason");
     }
-    if (v.reason !== undefined && typeof v.reason !== "string")
+    if (reason !== undefined && typeof reason !== "string")
         return bad("reason must be a string when present", "reason");
     return true;
-};
-const checkSeatModelCatalog = (v) => {
-    if (!isObject(v))
+});
+const checkLiveModelCatalog = seatCheck((v) => {
+    if (!isObject(v) || Array.isArray(v))
         return bad("model catalog is not an object");
-    const models = v.models;
+    const models = own(v, "models");
     if (!Array.isArray(models))
         return bad("models must be an array", "models");
-    for (let i = 0; i < models.length; i += 1) {
-        const verdict = checkSeatModelInfo(models[i], i);
-        if (verdict !== true)
-            return verdict;
+    const rows = ownItems(models);
+    const names = new Set();
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = liveModelRowCopy(rows[i]);
+        if (row === undefined)
+            return bad(`models[${i}] is not a catalog row (an object whose name is a non-empty string, JSON values only)`, `models[${i}]`);
+        if (names.has(row.name))
+            return bad(`models[${i}] repeats the name of an earlier row`, `models[${i}].name`);
+        names.add(row.name);
+    }
+    const dflt = own(v, "default");
+    if (typeof dflt !== "string" || dflt.length === 0)
+        return bad("default must be a non-empty string", "default");
+    const defaultModel = own(v, "defaultModel");
+    if (!isAbsent(defaultModel) && liveDefaultModelCopy(defaultModel) === undefined) {
+        return bad("defaultModel must be {id: non-empty string, name?: non-empty string} when present", "defaultModel");
     }
-    if (!optionalString(v.defaultId))
-        return bad("defaultId must be a string when present", "defaultId");
     return true;
-};
-export function isSeatModelCatalog(v) {
-    return checkSeatModelCatalog(v) === true;
+});
+const checkSeatRewindIntent = seatCheck((v) => {
+    if (!isObject(v) || Array.isArray(v))
+        return bad("rewind must be an object {mode, targetMessageUuid}");
+    for (const k of Object.keys(v)) {
+        if (!inTuple(SEAT_REWIND_INTENT_KEYS, k))
+            return bad(`unknown key (closed shape: ${SEAT_REWIND_INTENT_KEYS.join(", ")})`, k);
+    }
+    const mode = own(v, "mode");
+    if (typeof mode !== "string" || !inTuple(REWIND_MODES, mode))
+        return bad(`mode must be one of ${REWIND_MODES.join("|")}`, "mode");
+    const target = own(v, "targetMessageUuid");
+    if (typeof target !== "string" || target.length === 0) {
+        return bad("targetMessageUuid must be a non-empty string", "targetMessageUuid");
+    }
+    return true;
+});
+const checkSeatTurnSettings = seatCheck((v) => {
+    if (!isObject(v) || Array.isArray(v))
+        return bad("settings must be an object");
+    for (const k of Object.keys(v)) {
+        if (!inTuple(SEAT_TURN_SETTINGS_KEYS, k)) {
+            const host = Object.hasOwn(SEAT_TURN_SETTINGS_ORIGINS, k);
+            return bad(host ? "this settings key is supplied by the host, not carried by the seat" : `unknown key (closed shape: ${SEAT_TURN_SETTINGS_KEYS.join(", ")})`, k);
+        }
+    }
+    const ultracode = own(v, "ultracode");
+    if (!isAbsent(ultracode) && typeof ultracode !== "boolean")
+        return bad("ultracode must be a boolean when present", "ultracode");
+    return true;
+});
+const checkRetainSubagentSessions = seatCheck((v) => {
+    if (typeof v === "boolean")
+        return true;
+    if (!isObject(v) || Array.isArray(v))
+        return bad("retainSubagentSessions must be a boolean or {ttlMs?, max?}");
+    for (const k of Object.keys(v)) {
+        if (k !== "ttlMs" && k !== "max")
+            return bad("unknown key (closed shape: ttlMs, max)", k);
+        const n = own(v, k);
+        if (!isAbsent(n) && (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0))
+            return bad(`${k} must be a non-negative integer when present`, k);
+    }
+    return true;
+});
+export function checkSendMessageRequest(v) {
+    try {
+        if (!isObject(v) || Array.isArray(v))
+            return bad("sendMessage request is not an object");
+        const at = firstAccessorPath(v);
+        if (at !== undefined)
+            return bad(NOT_PLAIN_DATA, at);
+        const body = {};
+        for (const k of Object.keys(v)) {
+            if (!inTuple(SEND_MESSAGE_REQUEST_KEYS, k))
+                return bad(`unknown key (closed shape: ${SEND_MESSAGE_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");
+        if (typeof body.text !== "string")
+            return bad("text must be a string", "text");
+        if (!optionalString(body.model))
+            return bad("model must be a string when present", "model");
+        if (!optionalString(body.userMessageUuid))
+            return bad("userMessageUuid must be a string when present", "userMessageUuid");
+        if (!isAbsent(body.permissionMode) && (typeof body.permissionMode !== "string" || !inTuple(PERMISSION_MODE_INTENTS, body.permissionMode))) {
+            return bad(`permissionMode must be one of ${PERMISSION_MODE_INTENTS.join("|")}`, "permissionMode");
+        }
+        if (!isAbsent(body.attachmentIds)) {
+            const raw = body.attachmentIds;
+            const ids = Array.isArray(raw) ? ownItems(raw) : undefined;
+            if (ids === undefined || !ids.every((id) => typeof id === "string" && id.length > 0)) {
+                return bad("attachmentIds must be an array of non-empty attachment ids", "attachmentIds");
+            }
+            if (ids.length > ATTACHMENT_IDS_PER_TASK_CAP)
+                return bad(`attachmentIds exceeds the per-task limit (${ATTACHMENT_IDS_PER_TASK_CAP})`, "attachmentIds");
+        }
+        if (!isAbsent(body.reasoningEffort) && (typeof body.reasoningEffort !== "string" || !inTuple(SEAT_REASONING_EFFORTS, body.reasoningEffort))) {
+            return bad(`reasoningEffort must be one of ${SEAT_REASONING_EFFORTS.join("|")}`, "reasoningEffort");
+        }
+        for (const k of ["retainBackgroundProcesses", "forwardSubagentEvents"]) {
+            if (!isAbsent(body[k]) && typeof body[k] !== "boolean")
+                return bad(`${k} must be a boolean when present`, k);
+        }
+        if (!isAbsent(body.retainSubagentSessions)) {
+            const verdict = checkRetainSubagentSessions(body.retainSubagentSessions);
+            if (verdict !== true)
+                return nested("retainSubagentSessions", verdict);
+        }
+        if (!isAbsent(body.settings)) {
+            const verdict = checkSeatTurnSettings(body.settings);
+            if (verdict !== true)
+                return nested("settings", verdict);
+        }
+        if (!optionalString(body.scenario))
+            return bad("scenario must be a string when present", "scenario");
+        if (!isAbsent(body.rewind)) {
+            const verdict = checkSeatRewindIntent(body.rewind);
+            if (verdict !== true)
+                return nested("rewind", verdict);
+        }
+        return true;
+    }
+    catch (e) {
+        const key = ownDataRefusalKeyOf(e);
+        return key !== undefined ? bad(NOT_PLAIN_DATA, key) : bad("sendMessage request could not be read");
+    }
+}
+export function isSendMessageRequest(v) {
+    return checkSendMessageRequest(v) === true;
 }
-const checkSendMessageAck = (v) => {
+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");
-    if (typeof v.sessionId !== "string")
+    if (typeof own(v, "sessionId") !== "string")
         return bad("sessionId must be a string", "sessionId");
-    if (typeof v.userMessageUuid !== "string")
+    if (typeof own(v, "userMessageUuid") !== "string")
         return bad("userMessageUuid must be a string", "userMessageUuid");
-    if (!isAbsent(v.queued) && typeof v.queued !== "boolean")
+    const queued = own(v, "queued");
+    if (!isAbsent(queued) && typeof queued !== "boolean")
         return bad("queued must be a boolean when present", "queued");
     return true;
-};
+});
 export function isSendMessageAck(v) {
     return checkSendMessageAck(v) === true;
 }
-const checkInterruptAck = (v) => isObject(v) && typeof v.interrupted === "boolean" ? true : bad("interrupt ack needs boolean `interrupted`", "interrupted");
-const checkStopAck = (v) => isObject(v) && typeof v.stopped === "boolean" ? true : bad("stop ack needs boolean `stopped`", "stopped");
-const checkOkAck = (v) => isObject(v) && typeof v.ok === "boolean" ? true : bad("ack needs boolean `ok`", "ok");
+const checkInterruptAck = seatCheck((v) => isObject(v) && typeof own(v, "interrupted") === "boolean" ? true : bad("interrupt ack needs boolean `interrupted`", "interrupted"));
+const checkStopAck = seatCheck((v) => isObject(v) && typeof own(v, "stopped") === "boolean" ? true : bad("stop ack needs boolean `stopped`", "stopped"));
+const checkOkAck = seatCheck((v) => isObject(v) && typeof own(v, "ok") === "boolean" ? true : bad("ack needs boolean `ok`", "ok"));
 const checkBooleanAck = (v) => typeof v === "boolean" ? true : bad("expected a bare boolean result");
-const checkGetTranscriptResult = (v) => {
+const checkGetTranscriptResult = seatCheck((v) => {
     if (!isObject(v))
         return bad("transcript envelope is not an object");
-    if (typeof v.sessionId !== "string")
+    if (typeof own(v, "sessionId") !== "string")
         return bad("sessionId must be a string", "sessionId");
-    if (!Array.isArray(v.messages))
+    if (!Array.isArray(own(v, "messages")))
         return bad("messages must be an array", "messages");
     return true;
-};
-const checkSessionSearchResult = (v) => {
+});
+const checkSessionSearchResult = seatCheck((v) => {
     if (!isObject(v))
         return bad("search result row is not an object");
-    if (typeof v.sessionId !== "string")
+    if (typeof own(v, "sessionId") !== "string")
         return bad("sessionId must be a string", "sessionId");
-    if (!optionalString(v.title))
+    if (!optionalString(own(v, "title")))
         return bad("title must be a string when present", "title");
-    if (!Array.isArray(v.matches))
+    const matches = own(v, "matches");
+    if (!Array.isArray(matches))
         return bad("matches must be an array", "matches");
-    const okMatches = v.matches.every((m) => isObject(m) && typeof m.snippet === "string");
+    const okMatches = ownItems(matches).every((m) => isObject(m) && typeof own(m, "snippet") === "string");
     if (!okMatches)
         return bad("matches must be {snippet:string}[]", "matches");
     return true;
-};
-const checkSessionSearchEnvelope = (v) => {
+});
+const checkSessionSearchEnvelope = seatCheck((v) => {
     if (!isObject(v))
         return bad("search envelope is not an object");
-    const results = v.results;
+    const results = own(v, "results");
     if (!Array.isArray(results))
         return bad("results must be an array", "results");
-    for (let i = 0; i < results.length; i += 1) {
-        const verdict = checkSessionSearchResult(results[i]);
+    const rows = ownItems(results);
+    for (let i = 0; i < rows.length; i += 1) {
+        const verdict = checkSessionSearchResult(rows[i]);
         if (verdict !== true)
             return nested(`results[${i}]`, verdict);
     }
     return true;
-};
-const checkSessionsState = (v) => {
+});
+const checkSessionsState = seatCheck((v) => {
     if (!isObject(v))
         return bad("sessions state is not an object");
-    const sessions = v.sessions;
+    const sessions = own(v, "sessions");
     if (!Array.isArray(sessions))
         return bad("sessions must be an array", "sessions");
-    for (let i = 0; i < sessions.length; i += 1) {
-        const verdict = checkLocalSessionRecord(sessions[i]);
+    const rows = ownItems(sessions);
+    for (let i = 0; i < rows.length; i += 1) {
+        const verdict = checkLocalSessionRecord(rows[i]);
         if (verdict !== true)
             return nested(`sessions[${i}]`, verdict);
     }
     return true;
-};
-const checkFocusedSessionState = (v) => {
+});
+const checkFocusedSessionState = seatCheck((v) => {
     if (!isObject(v))
         return bad("focused session state is not an object");
-    if (v.sessionId !== null && typeof v.sessionId !== "string") {
+    const sessionId = own(v, "sessionId");
+    if (sessionId !== null && typeof sessionId !== "string") {
         return bad("sessionId must be a string or null", "sessionId");
     }
     return true;
-};
-const checkSettingsState = (v) => {
-    if (!isObject(v))
-        return bad("settings state is not an object");
-    if (v.defaultModel !== null && typeof v.defaultModel !== "string") {
-        return bad("defaultModel must be a string or null", "defaultModel");
+});
+const checkSettingsState = seatCheck((v) => {
+    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(v.engineVersion))
+    if (!optionalString(own(v, "engineVersion")))
         return bad("engineVersion must be a string when present", "engineVersion");
-    if (!optionalString(v.dataRoot))
+    if (!optionalString(own(v, "dataRoot")))
         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 checkSeatCapabilitiesState = (v) => {
-    try {
-        if (!isObject(v) || Array.isArray(v))
-            return bad("seat capabilities state is not an object");
-        const proto = Object.getPrototypeOf(v);
-        if (proto !== Object.prototype && proto !== null)
-            return bad("seat capabilities state is not a plain object");
-        for (const k of Reflect.ownKeys(v)) {
-            const name = typeof k === "string" ? k : String(k);
-            if (typeof k !== "string" || !inTuple(SEAT_CAPABILITY_NAMES, k)) {
-                return bad(`${name} is not a registered seat capability (${SEAT_CAPABILITY_NAMES.join("|")})`, name);
-            }
-            const desc = Object.getOwnPropertyDescriptor(v, k);
-            if (desc === undefined || !("value" in desc))
-                return bad(`${k} must be a plain data property (accessors are refused)`, k);
-            if (!isAbsent(desc.value) && typeof desc.value !== "boolean")
-                return bad(`${k} must be a boolean when present`, k);
-        }
-        return true;
+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);
     }
-    catch {
-        return bad("seat capabilities state could not be read");
+    return true;
+});
+const checkSeatCapabilitiesState = seatCheck((v) => {
+    if (!isObject(v) || Array.isArray(v))
+        return bad("seat capabilities state is not an object");
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== Object.prototype && proto !== null)
+        return bad("seat capabilities state is not a plain object");
+    for (const k of Reflect.ownKeys(v)) {
+        const name = typeof k === "string" ? k : String(k);
+        if (typeof k !== "string" || !inTuple(SEAT_CAPABILITY_NAMES, k)) {
+            return bad(`${name} is not a registered seat capability (${SEAT_CAPABILITY_NAMES.join("|")})`, name);
+        }
+        const value = own(v, k);
+        if (!isAbsent(value) && typeof value !== "boolean")
+            return bad(`${k} must be a boolean when present`, k);
     }
-};
+    return true;
+});
 export const LOCAL_SESSIONS_SPEC = {
     ns: "sema.web",
     service: "LocalSessions",
@@ -533,9 +878,11 @@ export const LOCAL_SESSIONS_SPEC = {
         getTranscript: { kind: "invoke", check: checkGetTranscriptResult },
         searchSessions: { kind: "invoke", check: checkSessionSearchEnvelope },
         uploadAttachment: { kind: "invoke", check: checkAttachmentUploadReceipt },
-        listModels: { kind: "invoke", check: checkSeatModelCatalog },
+        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 },
     },
@@ -563,6 +910,8 @@ export const SEAT_METHOD_NAMES = [
     "listModels",
     "applyModelConfig",
     "pickFolder",
+    "listRecentFolders",
+    "noteRecentFolder", "patchSession",
     "onEvent",
     "onToolPermissionRequest",
 ];
@@ -590,6 +939,7 @@ export const LOCAL_SESSION_EVENT_KEYS = [
     "hasPreClearSession",
     "requestId",
     "outcome",
+    "parked",
     "chrome",
 ];
 export const TOOL_PERMISSION_REQUEST_KEYS = [
@@ -609,6 +959,7 @@ export const TOOL_PERMISSION_REQUEST_KEYS = [
     "ruleOffersAbsence",
     "askClass",
     "classes",
+    "rememberRefused",
 ];
 export const LOCAL_SESSION_RECORD_KEYS = [
     "sessionId",
@@ -621,6 +972,7 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "lastActivityAt",
     "queuedMessages",
     "parked",
+    "pinned",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
     "sessionId",
@@ -635,6 +987,7 @@ export const SEND_MESSAGE_REQUEST_KEYS = [
     "retainSubagentSessions",
     "settings",
     "scenario",
+    "rewind",
 ];
 export const SEAT_SEND_MESSAGE_KEY_ORIGINS = {
     sessionId: { seatOnly: "座位会话句柄(渲染端持有的本地 id);引擎会话 id 由座位记录的 `engineSessionId` 承载 —— 与引擎请求体上的同名位**同名不同义**,绝不直传" },
@@ -649,6 +1002,7 @@ export const SEAT_SEND_MESSAGE_KEY_ORIGINS = {
     retainSubagentSessions: { taskRequestKey: "retainSubagentSessions" },
     settings: { taskRequestKey: "settings" },
     scenario: { taskRequestKey: "scenario" },
+    rewind: { projectedBy: "rewindSpecForMode", taskRequestKeys: ["resumeAt", "resumeAtMode", "restoreFiles", "rewindFilesTo"] },
 };
 export const TOOL_PERMISSION_DECISION_KEYS = [
     "sessionId",
@@ -663,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: {
@@ -703,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。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
@@ -728,6 +1086,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
             "hasPreClearSession",
             "requestId",
             "outcome",
+            "parked",
             "chrome",
         ],
         unchecked: [
@@ -743,10 +1102,40 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         validated: ["id", "name", "mime", "sha256", "sizeBytes"],
         unchecked: [],
     },
-    SeatModelCatalog: {
-        guard: "isSeatModelCatalog",
-        check: checkSeatModelCatalog,
-        validated: ["models", "defaultId"],
+    LiveModelCatalog: {
+        check: checkLiveModelCatalog,
+        validated: ["models", "default", "defaultModel"],
+        unchecked: [
+            {
+                key: "droppedEntries",
+                why: "诊断面(哪些目录条目没被引擎收下),三态读法归 droppedModelEntriesOf(含坏形 malformed);出站门为它拒掉整份目录 = 选单为一行诊断整个消失。",
+            },
+        ],
+    },
+    SendMessageRequest: {
+        guard: "isSendMessageRequest",
+        check: checkSendMessageRequest,
+        validated: [
+            "sessionId",
+            "text",
+            "model",
+            "userMessageUuid",
+            "permissionMode",
+            "attachmentIds",
+            "reasoningEffort",
+            "retainBackgroundProcesses",
+            "forwardSubagentEvents",
+            "retainSubagentSessions",
+            "settings",
+            "scenario",
+            "rewind",
+        ],
+        unchecked: [],
+    },
+    SessionRowPatchRequest: {
+        guard: "isSessionRowPatchRequest",
+        check: checkSessionRowPatchRequest,
+        validated: ["sessionId", "title", "pinned"],
         unchecked: [],
     },
     ApplyModelConfigResult: {
@@ -797,17 +1186,27 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SettingsState: {
         check: checkSettingsState,
-        validated: ["defaultModel", "engineVersion", "dataRoot"],
+        validated: ["engineVersion", "dataRoot"],
         unchecked: [],
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession"],
         unchecked: [],
     },
-    SeatModelInfo: {
-        check: (v) => checkSeatModelInfo(v, 0),
-        validated: ["id", "name", "provider", "contextWindow", "maxOutputTokens"],
+    RecentFoldersResult: {
+        check: checkRecentFoldersResult,
+        validated: ["folders"],
+        unchecked: [],
+    },
+    RecentFolderRow: {
+        check: checkRecentFolderRow,
+        validated: ["path", "lastUsedAt"],
+        unchecked: [],
+    },
+    SeatRewindIntent: {
+        check: checkSeatRewindIntent,
+        validated: ["mode", "targetMessageUuid"],
         unchecked: [],
     },
     SessionSearchResult: {
@@ -864,5 +1263,10 @@ 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, true, true,
+    true, true, true, true, true, true,
 ];
 void _seatContractPins;