@sema-agent/client-core 0.107.0 → 0.109.0

package/dist/seatContract.js

@@ -4,10 +4,13 @@ import { REWIND_MODES } from "./rewindWireCaps.js";
 import { SETTINGS_MODEL_API_WORDS } from "./generated/settingsSchemaTables.js";
 import { PROBE_VERDICTS } from "./modelCapabilityProbe.js";
 import { guardedRead, ownDataField, ownDataRefusalKeyOf, ownSendableField, readOwnDataValue } from "./ownKey.js";
+import { isPlainRecord as isJsonPlainRecord } from "./jsonFaithful.js";
+import { displayUntrustedMarks, quoteUntrustedForSentence } from "./displayUntrusted.js";
 import { MCP_LIVENESS_STATES } from "./mcpLiveness.js";
 import { THINKING_LATCH_EVENTS, THINKING_LATCH_ROW_WORDS } from "./thinkingLatchWords.js";
 import { EXECUTION_PLACEMENT_ROLES } from "./executionPlacementWords.js";
 import { isSessionEngineView } from "./sessionEngine.js";
+import { LOCAL_ENGINE_SWAP_CAUSES } from "./localEngineSwapCard.js";
 const bad = (reason, field) => field === undefined ? { reason } : { reason, field };
 const nested = (prefix, verdict) => {
     const path = verdict.field === undefined
@@ -18,12 +21,7 @@ const nested = (prefix, verdict) => {
     const reason = verdict.reason.startsWith(`${prefix}:`) ? verdict.reason : `${prefix}: ${verdict.reason}`;
     return bad(reason, path);
 };
-const isPlainRecord = (v) => {
-    if (typeof v !== "object" || v === null || Array.isArray(v))
-        return false;
-    const proto = Object.getPrototypeOf(v);
-    return proto === null || (typeof proto === "object" && Object.getPrototypeOf(proto) === null);
-};
+const isPlainRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && isJsonPlainRecord(v);
 const isAbsent = (v) => typeof v === "undefined";
 const optionalString = (v) => isAbsent(v) || typeof v === "string";
 const isFolderPath = (v) => typeof v === "string" && v.length > 0;
@@ -185,6 +183,23 @@ const R_NUM = ruleOf("finite number", (v) => typeof v === "number" && Number.isF
 const R_NUM0 = ruleOf("finite non-negative number", (v) => typeof v === "number" && Number.isFinite(v) && v >= 0);
 const R_INT0 = ruleOf("non-negative integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0);
 const R_INT1 = ruleOf("positive integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v > 0);
+const SESSION_ENGINE_KIND_WORDS = Object.freeze(["local", "cloud"]);
+const R_ENGINE_LANE = oneOfRule("engine lane", SESSION_ENGINE_KIND_WORDS);
+const R_ROW_BAR = armsRule("row verdict", "kind", {
+    lacking: { code: reqF(R_NONEMPTY), reason: optF(R_NONEMPTY), requires: optF(arrayRule(R_NONEMPTY)), sentence: reqF(R_NONEMPTY) },
+    damaged: { code: reqF(R_NONEMPTY), reason: optF(R_NONEMPTY), requires: optF(arrayRule(R_NONEMPTY)), sentence: reqF(R_NONEMPTY) },
+    unknown: { word: reqF(R_NONEMPTY), sentence: optF(R_NONEMPTY) },
+    unreadable: {},
+});
+const PARKED_ROW_DEADLINE_WORDS = Object.freeze(["armed", "none"]);
+const R_PARKED_ROW = shapeRule("parked row", {
+    rowVerdict: reqF(R_ROW_BAR),
+    rowKey: optF(R_NONEMPTY),
+    taskId: optF(R_NONEMPTY),
+    toolName: optF(R_NONEMPTY),
+    rowDeadline: optF(oneOfRule("deadline word", PARKED_ROW_DEADLINE_WORDS)),
+});
+const R_PARKED_UNRESUMABLE = arrayRule(R_PARKED_ROW, true);
 const keyWords = (k) => k
     .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
     .toLowerCase()
@@ -294,6 +309,7 @@ const CHROME_ARM_SEAT_ROUTE = {
     compaction_started: "seat",
     compaction_outcome: "seat",
     engine_notice: "seat",
+    subagent_alias: "seat",
     workflow_notification_enqueue: "host",
     plan_review_park: "host",
     approval_request: "host",
@@ -333,6 +349,7 @@ export const HITL_RESOLUTION_OUTCOMES = [
     "accept",
     "decline",
     "cancel",
+    "engine_unavailable",
 ];
 export const SEAT_STREAM_DELTA_TYPE_OF_CHANNEL = Object.freeze({ text: "text_delta", thinking: "thinking_delta" });
 export function seatStreamDeltaMessage(event, ids) {
@@ -381,7 +398,7 @@ export function readSeatStreamDelta(message) {
         return Object.freeze({ kind: "malformed" });
     }
 }
-export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -460,6 +477,7 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     thinkingLatch: Object.freeze({ action: "Switching thinking", ability: "switch thinking", support: "thinking-switch support" }),
     computerUseSwitch: Object.freeze({ action: "Computer use", ability: "be switched", support: "switch support" }),
     engineModeDefaultOnly: Object.freeze({ action: "Default-only engine switching", ability: "keep existing sessions on their engine", support: "default-only engine switching" }),
+    seatActions: Object.freeze({ action: "App menu actions", ability: "send actions to this window", support: "app action support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -668,6 +686,7 @@ export const ENGINE_TARGET_REFUSALS = Object.freeze([
     "not_configured",
     "not_signed_in",
     "probe_failed",
+    "cloud_unreachable",
     "org_policy",
     "url_refused",
     "login_failed",
@@ -685,6 +704,18 @@ export const CLOUD_LOGIN_FAILURES = Object.freeze([
     "no_tokens",
     "other",
 ]);
+export const LOCAL_ENGINE_DOWN_REASONS = Object.freeze([
+    "lock-unavailable",
+    "spawn-failed",
+    "spawn-refused",
+    "stop-failed",
+    "crash-loop",
+    "high-water-unreadable",
+    "principal-unknown",
+]);
+export const LOCAL_ENGINE_WAITING_REASONS = Object.freeze(["starting", "dormant", "draining", "unanswered", "peer"]);
+export const ENGINE_SWAP_ANSWER_OUTCOMES = Object.freeze(["started", "stale-card", "nothing-pending"]);
+export const SELF_UPGRADE_OUTCOMES = Object.freeze(["started", "unavailable"]);
 const R_ISO = R_NONEMPTY;
 const R_LOGIN_FAILURE = oneOfRule("login failure", CLOUD_LOGIN_FAILURES);
 const R_DISPLAY_URL = ruleOf("display url", (v) => {
@@ -761,12 +792,84 @@ const ENGINE_TARGET_CLOUD = shapeRule("cloud", {
     })),
     orgEngine: optF(shapeRule("org engine", { url: reqF(R_DISPLAY_URL), required: reqF(R_BOOL) })),
 });
-const ENGINE_TARGET_LOCAL = shapeRule("local", {
+const R_FINITE_TIME = ruleOf("non-negative integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0);
+const SWAP_CARD_IDENTITY = shapeRule("engine identity", {
+    pid: optF(R_INT1),
+    instanceId: optF(R_NONEMPTY),
+    startedAt: optF(R_FINITE_TIME),
+});
+const SWAP_CARD_REF_SPEC = {
+    pid: reqF(R_INT1),
+    port: reqF(ruleOf("port", (v) => typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= 65535)),
+    identity: reqF(SWAP_CARD_IDENTITY),
+    version: optF(R_NONEMPTY),
+};
+const SWAP_CARD_PROCESS_SPEC = { pid: reqF(R_INT1), startedAt: optF(R_INT1) };
+const R_SWAP_CARD_TARGET = {
+    label: "card target",
+    test: (v, path) => {
+        if (!isPlainRecord(v))
+            return bad("not object", path === "" ? undefined : path);
+        return shapeVerdict(isAbsent(own(v, "identity")) ? SWAP_CARD_PROCESS_SPEC : SWAP_CARD_REF_SPEC, v, path);
+    },
+};
+const SWAP_CARD = shapeRule("swap card", {
+    cause: reqF(oneOfRule("swap cause", LOCAL_ENGINE_SWAP_CAUSES)),
+    target: reqF(R_SWAP_CARD_TARGET),
+    running: optF(R_NONEMPTY),
+    own: optF(R_NONEMPTY),
+    others: reqF(ruleOf("others count|null", (v) => {
+        if (v === null)
+            return true;
+        if (!isPlainRecord(v))
+            return false;
+        return shapeVerdict({ total: reqF(R_INT0), midTurn: reqF(R_INT0) }, v, "") === true;
+    })),
+    inflight: reqF(ruleOf("count|null", (v) => v === null || (typeof v === "number" && Number.isSafeInteger(v) && v >= 0))),
+    bgLive: reqF(ruleOf("count|null", (v) => v === null || (typeof v === "number" && Number.isSafeInteger(v) && v >= 0))),
+    unknown: reqF(arrayRule(oneOfRule("card unknown", ["others", "inflight", "bg", "self"]))),
+    forcedWithinMs: reqF(R_INT0),
+    fingerprint: reqF(R_NONEMPTY),
+});
+const LOCAL_ENGINE_SEAT_READING = armsRule("engine lifecycle", "phase", {
+    waiting: { why: reqF(oneOfRule("waiting reason", LOCAL_ENGINE_WAITING_REASONS)), unverifiable: optF(R_TRUE) },
+    attached: {},
+    pending: { serving: reqF(R_BOOL), card: optF(SWAP_CARD) },
+    swapping: { mode: reqF(oneOfRule("swap mode", ["idle", "forced"])) },
+    down: { reason: reqF(oneOfRule("down reason", LOCAL_ENGINE_DOWN_REASONS)) },
+    behind: { running: reqF(R_NONEMPTY), own: reqF(R_NONEMPTY), upgrade: reqF(oneOfRule("upgrade entry", ["available", "unavailable"])) },
+});
+const R_LIFECYCLE_DERIVED = ruleOf("lifecycle-derived", () => false);
+const R_LIFECYCLE_WITHDRAWN = ruleOf("lifecycle-withdrawn", () => false);
+const R_UNANSWERED_ONLY = ruleOf("unanswered-only", () => false);
+const ENGINE_TARGET_LOCAL_SPEC = {
     lastBootError: optF(R_STR),
     mcp: optF(SEAT_LOCAL_MCP_READING),
-});
+    lifecycle: optF(LOCAL_ENGINE_SEAT_READING),
+};
+const ENGINE_TARGET_LOCAL = {
+    label: "local",
+    test: (v, path) => {
+        const verdict = shapeVerdict(ENGINE_TARGET_LOCAL_SPEC, v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        const lifecycle = own(rec, "lifecycle");
+        if (isAbsent(lifecycle))
+            return true;
+        const phase = own(lifecycle, "phase");
+        const bootError = !isAbsent(own(rec, "lastBootError"));
+        if (bootError !== (phase === "down"))
+            return R_LIFECYCLE_DERIVED.test(undefined, pathAt(path, "lastBootError"));
+        if (phase !== "attached" && phase !== "pending" && !isAbsent(own(rec, "mcp")))
+            return R_LIFECYCLE_WITHDRAWN.test(undefined, pathAt(path, "mcp"));
+        if (phase === "waiting" && own(lifecycle, "why") !== "unanswered" && !isAbsent(own(lifecycle, "unverifiable")))
+            return R_UNANSWERED_ONLY.test(undefined, pathAt(pathAt(path, "lifecycle"), "unverifiable"));
+        return true;
+    },
+};
 const ENGINE_TARGET_STATE = shapeRule("engine target", {
-    mode: reqF(oneOfRule("engine mode", ["local", "cloud"])),
+    mode: reqF(R_ENGINE_LANE),
     generation: reqF(R_INT0),
     cloud: reqF(ENGINE_TARGET_CLOUD),
     local: reqF(ENGINE_TARGET_LOCAL),
@@ -792,6 +895,8 @@ const ENGINE_TARGET_REFUSED_SPEC = {
     detail: optF(R_STR),
 };
 const checkEngineTargetResult = seatShapeCheck(okArmsRule("engineTarget result", {}, ENGINE_TARGET_REFUSED_SPEC));
+const checkEngineSwapAnswerOutcome = seatShapeCheck(oneOfRule("swap answer", ENGINE_SWAP_ANSWER_OUTCOMES));
+const checkSelfUpgradeOutcome = seatShapeCheck(oneOfRule("self upgrade", SELF_UPGRADE_OUTCOMES));
 const checkCancelCloudLogin = seatShapeCheck(shapeRule("cancel ack", { ok: reqF(R_BOOL) }));
 const checkCloudLoginStart = seatShapeCheck(okArmsRule("startCloudLogin result", {
     verificationUri: reqF(R_DISPLAY_URL),
@@ -1064,6 +1169,119 @@ export function planSetComputerUse(request, lockedByEnv) {
         return Object.freeze({ kind: "refused", reason: "confirmation-required" });
     return Object.freeze({ kind: "apply", enabled: intent.kind === "enable" });
 }
+export const SEAT_ACTION_NAMES = Object.freeze(["new-project", "prefill-composer"]);
+const SEAT_PREFILL_TEXT_MAX = 14336;
+const SEAT_PREFILL_CWD_MAX = 4096;
+const SEAT_ACTIONS_CLAIM_MAX = 16;
+const SEAT_ACTION_WORD_MAX = 64;
+const SEAT_TEXT_FACE = Object.freeze({ foldLines: false, keepLayout: "crlf", credentialUrls: false, credentialWords: false });
+const SEAT_PATH_FACE = Object.freeze({ foldLines: false, credentialUrls: false, credentialWords: false });
+const faceClean = (v, face) => displayUntrustedMarks(v, face).marks.length === 0;
+const R_PREFILL_TEXT = ruleOf(`prefill text (1–${SEAT_PREFILL_TEXT_MAX} chars, no control, bidi or other invisible characters)`, (v) => typeof v === "string" && v.length > 0 && v.length <= SEAT_PREFILL_TEXT_MAX && faceClean(v, SEAT_TEXT_FACE));
+const R_PREFILL_CWD = ruleOf(`folder path (1–${SEAT_PREFILL_CWD_MAX} chars, no control, bidi or other invisible characters)`, (v) => isFolderPath(v) && v.length <= SEAT_PREFILL_CWD_MAX && faceClean(v, SEAT_PATH_FACE));
+const SEAT_ACTION_ARMS = {
+    "new-project": {},
+    "prefill-composer": { text: reqF(R_PREFILL_TEXT), cwd: optF(R_PREFILL_CWD) },
+};
+export const checkSeatAction = seatShapeCheck(armsRule("seat action", "action", SEAT_ACTION_ARMS));
+const seatActionMalformed = (reason) => Object.freeze({ kind: "malformed", reason });
+export function readSeatAction(ev) {
+    try {
+        if (!isPlainRecord(ev))
+            return seatActionMalformed("not a plain object");
+        const name = own(ev, "action");
+        if (typeof name !== "string")
+            return seatActionMalformed("action must be a string");
+        if (!inTuple(SEAT_ACTION_NAMES, name))
+            return Object.freeze({ kind: "unknown", name: name.slice(0, SEAT_ACTION_WORD_MAX) });
+        const verdict = checkSeatAction(ev);
+        if (verdict !== true) {
+            return seatActionMalformed(`${verdict.field ? `${verdict.field}: ` : ""}${verdict.reason}`);
+        }
+        if (name === "new-project")
+            return Object.freeze({ kind: "action", action: Object.freeze({ action: "new-project" }) });
+        const text = own(ev, "text");
+        const cwd = own(ev, "cwd");
+        if (R_PREFILL_TEXT.test(text, "text") !== true || typeof text !== "string")
+            return seatActionMalformed("text: payload changed while being read");
+        if (!isAbsent(cwd) && (R_PREFILL_CWD.test(cwd, "cwd") !== true || typeof cwd !== "string"))
+            return seatActionMalformed("cwd: payload changed while being read");
+        return Object.freeze({
+            kind: "action",
+            action: Object.freeze({ action: "prefill-composer", text, ...(typeof cwd === "string" ? { cwd } : {}) }),
+        });
+    }
+    catch {
+        return seatActionMalformed("payload could not be read");
+    }
+}
+const quoteSeatWord = (w) => quoteUntrustedForSentence(w, SEAT_ACTION_WORD_MAX) ?? '""';
+const R_CLAIM_WORD = {
+    label: "action word",
+    test: (v, path) => typeof v === "string"
+        ? inTuple(SEAT_ACTION_NAMES, v)
+            ? true
+            : bad(`unknown action word ${quoteSeatWord(v)} (closed set: ${SEAT_ACTION_NAMES.join("|")})`, path)
+        : bad("bad value (action word)", path),
+};
+const claimListOnce = (v, path) => {
+    const n = ownDataField(v, "length");
+    if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0)
+        return bad("bad value (action list)", path);
+    if (n > SEAT_ACTIONS_CLAIM_MAX)
+        return bad(`bad value (at most ${SEAT_ACTIONS_CLAIM_MAX} actions)`, path);
+    for (const k of Reflect.ownKeys(v)) {
+        if (typeof k === "string" && !isArraySlotKey(k, n))
+            return bad("unknown key", pathAt(path, k));
+    }
+    const words = [];
+    for (let i = 0; i < n; i += 1)
+        words.push(own(v, String(i)));
+    return words;
+};
+const R_CLAIM_LIST = {
+    label: `action list (at most ${SEAT_ACTIONS_CLAIM_MAX})`,
+    test: (v, path) => {
+        if (!Array.isArray(v))
+            return bad("bad value (action list)", path);
+        const words = claimListOnce(v, path);
+        if (!Array.isArray(words))
+            return words;
+        for (let i = 0; i < words.length; i += 1) {
+            const verdict = R_CLAIM_WORD.test(words[i], `${path}[${i}]`);
+            if (verdict !== true)
+                return verdict;
+        }
+        return true;
+    },
+};
+const checkSeatActionsClaimShape = seatShapeCheck(shapeRule("seat actions claim", { actions: reqF(R_CLAIM_LIST) }));
+export const checkSeatActionsClaim = seatCheck((v) => isPlainRecord(v) ? checkSeatActionsClaimShape(v) : bad("claimSeatActions request is not a plain object"));
+export function claimedSeatActionsOf(claim) {
+    try {
+        if (!isPlainRecord(claim))
+            return Object.freeze([]);
+        const snap = Object.create(null);
+        for (const k of Reflect.ownKeys(claim)) {
+            if (typeof k === "string")
+                snap[k] = own(claim, k);
+        }
+        const list = snap.actions;
+        if (Array.isArray(list)) {
+            const words = claimListOnce(list, "actions");
+            if (!Array.isArray(words))
+                return Object.freeze([]);
+            snap.actions = words;
+        }
+        if (checkSeatActionsClaim(snap) !== true)
+            return Object.freeze([]);
+        const taken = snap.actions;
+        return Object.freeze(SEAT_ACTION_NAMES.filter((name) => taken.includes(name)));
+    }
+    catch {
+        return Object.freeze([]);
+    }
+}
 const checkLocalSessionRecord = seatCheck((s) => {
     if (!isPlainRecord(s))
         return bad("session record is not a plain object");
@@ -1125,11 +1343,77 @@ const checkLocalSessionRecord = seatCheck((s) => {
     if (!isAbsent(lane) && (typeof lane !== "string" || lane.length === 0)) {
         return bad("executionLane must be a non-empty string when present (absent = no writer lane reading)", "executionLane");
     }
+    const parkedRows = own(s, "parkedUnresumable");
+    if (!isAbsent(parkedRows)) {
+        const verdict = R_PARKED_UNRESUMABLE.test(parkedRows, "parkedUnresumable");
+        if (verdict !== true)
+            return verdict;
+        if (parked === false)
+            return bad("bad value (parked:false)", "parkedUnresumable");
+    }
     return true;
 });
 export function isLocalSessionRecord(s) {
     return checkLocalSessionRecord(s) === true;
 }
+const checkParkedUnresumableSlot = seatCheck((v) => R_PARKED_UNRESUMABLE.test(v, "parkedUnresumable"));
+const parkedVerdictCopy = (rv) => {
+    const kind = own(rv, "kind");
+    const str = (k) => {
+        const x = own(rv, k);
+        return typeof x === "string" ? x : undefined;
+    };
+    const sentence = str("sentence");
+    if (kind === "lacking" || kind === "damaged") {
+        const reason = str("reason");
+        const requires = own(rv, "requires");
+        return Object.freeze({
+            kind,
+            code: str("code") ?? "",
+            ...(reason !== undefined ? { reason } : {}),
+            ...(Array.isArray(requires) ? { requires: Object.freeze(ownItems(requires).filter((w) => typeof w === "string")) } : {}),
+            sentence: sentence ?? "",
+        });
+    }
+    if (kind === "unknown")
+        return Object.freeze({ kind, word: str("word") ?? "", ...(sentence !== undefined ? { sentence } : {}) });
+    return Object.freeze({ kind: "unreadable" });
+};
+const parkedRowCopy = (item) => {
+    const str = (k) => {
+        const x = own(item, k);
+        return typeof x === "string" ? x : undefined;
+    };
+    const rv = own(item, "rowVerdict");
+    const rowKey = str("rowKey");
+    const taskId = str("taskId");
+    const toolName = str("toolName");
+    const rowDeadline = str("rowDeadline");
+    return Object.freeze({
+        rowVerdict: parkedVerdictCopy(typeof rv === "object" && rv !== null ? rv : {}),
+        ...(rowKey !== undefined ? { rowKey } : {}),
+        ...(taskId !== undefined ? { taskId } : {}),
+        ...(toolName !== undefined ? { toolName } : {}),
+        ...(rowDeadline === "armed" || rowDeadline === "none" ? { rowDeadline } : {}),
+    });
+};
+export function readSeatParkedUnresumable(record) {
+    try {
+        if (typeof record !== "object" || record === null)
+            return undefined;
+        const v = own(record, "parkedUnresumable");
+        if (isAbsent(v))
+            return undefined;
+        if (own(record, "parked") === false)
+            return undefined;
+        if (checkParkedUnresumableSlot(v) !== true)
+            return undefined;
+        return Object.freeze(ownItems(v).map((item) => parkedRowCopy(item)));
+    }
+    catch {
+        return undefined;
+    }
+}
 const checkToctouBinding = seatCheck((v) => {
     if (!isPlainRecord(v))
         return bad("toctouBinding must be a plain object", "toctouBinding");
@@ -1608,6 +1892,16 @@ export const checkSetThinkingLatchRequest = seatCheck((v) => isPlainRecord(v) ?
 export function isSetThinkingLatchRequest(v) {
     return checkSetThinkingLatchRequest(v) === true;
 }
+const checkStartSessionOptionsShape = seatShapeCheck(shapeRule("start options", {
+    model: optF(R_STR),
+    title: optF(R_STR),
+    cwd: optF(R_STR),
+    excludeTools: optF(arrayRule(R_STR)),
+    engine: optF(R_ENGINE_LANE),
+}));
+export const checkStartSessionOptions = seatCheck((v) => isAbsent(v) ? true : isPlainRecord(v) ? checkStartSessionOptionsShape(v) : bad("start options are not a plain object"));
+const checkSeatResourceScopeShape = seatShapeCheck(shapeRule("resource scope", { sessionId: reqF(R_NONEMPTY) }));
+export const checkSeatResourceScope = seatCheck((v) => isAbsent(v) ? true : isPlainRecord(v) ? checkSeatResourceScopeShape(v) : bad("resource scope is not a plain object"));
 const checkSendMessageAck = seatCheck((v) => {
     if (!isPlainRecord(v))
         return bad("sendMessage ack is not a plain object");
@@ -1773,6 +2067,8 @@ export const LOCAL_SESSIONS_SPEC = {
         connectCloudEngine: { kind: "invoke", check: checkCloudConnectResult },
         configureCloudEngine: { kind: "invoke", check: checkCloudConnectResult },
         clearCloudEngine: { kind: "invoke", check: checkEngineTargetResult },
+        answerEngineSwap: { kind: "invoke", check: checkEngineSwapAnswerOutcome },
+        beginSelfUpgrade: { kind: "invoke", check: checkSelfUpgradeOutcome },
         listOnboardProviders: { kind: "invoke", check: checkOnboardProvidersResult },
         probeOnboardEntry: { kind: "invoke", check: checkOnboardProbeResult },
         applyOnboardEntry: { kind: "invoke", check: checkOnboardApplyResult },
@@ -1782,8 +2078,10 @@ export const LOCAL_SESSIONS_SPEC = {
         setThinkingLatch: { kind: "invoke", check: checkOkAck },
         getComputerUse: { kind: "invoke", check: checkComputerUseState },
         setComputerUse: { kind: "invoke", check: checkSetComputerUseResult },
+        claimSeatActions: { kind: "invoke", check: checkOkAck },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
+        onSeatAction: { kind: "event", check: checkSeatAction },
     },
     stores: {
         sessionsState: { check: checkSessionsState },
@@ -1823,6 +2121,8 @@ export const SEAT_METHOD_NAMES = [
     "connectCloudEngine",
     "configureCloudEngine",
     "clearCloudEngine",
+    "answerEngineSwap",
+    "beginSelfUpgrade",
     "listOnboardProviders",
     "probeOnboardEntry",
     "applyOnboardEntry",
@@ -1832,8 +2132,10 @@ export const SEAT_METHOD_NAMES = [
     "setThinkingLatch",
     "getComputerUse",
     "setComputerUse",
+    "claimSeatActions",
     "onEvent",
     "onToolPermissionRequest",
+    "onSeatAction",
 ];
 export const SEAT_STORE_PROPS = [
     "sessionsStateStore",
@@ -1842,7 +2144,7 @@ export const SEAT_STORE_PROPS = [
     "seatCapabilitiesStateStore",
     "engineTargetStateStore",
 ];
-export const SEAT_EVENT_METHOD_NAMES = ["onEvent", "onToolPermissionRequest"];
+export const SEAT_EVENT_METHOD_NAMES = ["onEvent", "onToolPermissionRequest", "onSeatAction"];
 export const LOCAL_SESSION_EVENT_KEYS = [
     "type",
     "sessionId",
@@ -1895,6 +2197,7 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "thinkingLatch",
     "engine",
     "executionLane",
+    "parkedUnresumable",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
     "sessionId",
@@ -1934,12 +2237,12 @@ export const TOOL_PERMISSION_DECISION_KEYS = [
     "updatedInput",
     "remember",
 ];
-export const START_SESSION_OPTION_KEYS = ["model", "title", "cwd", "excludeTools"];
+export const START_SESSION_OPTION_KEYS = ["model", "title", "cwd", "excludeTools", "engine"];
 export const SEAT_VALIDATOR_KEY_COVERAGE = {
     LocalSessionRecord: {
         guard: "isLocalSessionRecord",
         check: checkLocalSessionRecord,
-        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "unreadable", "thinkingLatch", "engine", "executionLane"],
+        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "unreadable", "thinkingLatch", "engine", "executionLane", "parkedUnresumable"],
         unchecked: [],
     },
     ToolPermissionRequest: {
@@ -2039,6 +2342,10 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "modelPlane",
                 why: "诊断面(0.106.0 CC-1156;这台引擎服务的是哪张模型表 / 最近一份目录候选的结局),三态读法归 modelPlaneOf(含坏形 unreadable、表外词整位不给);出站门为它拒掉整份目录 = 选单为一行诊断整个消失。",
             },
+            {
+                key: "aliases",
+                why: "受理面(0.108.0 CC-944;除行名之外引擎还认的模型词),读法归 modelAcceptanceOf(缺席 = 更早的服务端,照旧判;在场而坏形 ⇒ 没找到行的词读 catalog_unreadable);出站门为它拒掉整份目录 = 选单为一份受理数据整个消失。",
+            },
         ],
     },
     SendMessageRequest: {
@@ -2073,6 +2380,21 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         validated: ["sessionId", "event"],
         unchecked: [],
     },
+    StartSessionOptions: {
+        check: checkStartSessionOptions,
+        validated: ["model", "title", "cwd", "excludeTools", "engine"],
+        unchecked: [],
+    },
+    SeatResourceScope: {
+        check: checkSeatResourceScope,
+        validated: ["sessionId"],
+        unchecked: [],
+    },
+    SeatActionsClaim: {
+        check: checkSeatActionsClaim,
+        validated: ["actions"],
+        unchecked: [],
+    },
     ApplyModelConfigResult: {
         check: checkApplyModelConfigResult,
         validated: ["ok", "requiresRestart", "reason", "detail"],
@@ -2126,7 +2448,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2192,6 +2514,9 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["ComputerUseState", checkComputerUseState],
         ["SetComputerUseResult", checkSetComputerUseResult],
         ["SetComputerUseRequest", checkSetComputerUseRequest],
+        ["SeatAction", checkSeatAction],
+        ["EngineSwapAnswerOutcome", checkEngineSwapAnswerOutcome],
+        ["SelfUpgradeOutcome", checkSelfUpgradeOutcome],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2251,5 +2576,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,
 ];
 void _seatContractPins;

package/dist/sessionBackground.js

@@ -34,6 +34,8 @@ export function readSessionBackgroundable(baseUrl = engineWireTargetBaseUrl()) {
         return Object.freeze({ kind: 'unobserved' });
     }
 }
+const localEngineLanePin = true;
+void localEngineLanePin;
 export const OPENING_RECORD_CAP = 256;
 const wireStates = new WeakMap();
 const isObj = (v) => (typeof v === 'object' && v !== null) || typeof v === 'function';

package/dist/sessionEngine.d.ts

@@ -134,7 +134,7 @@ export interface SessionEngineWiring {
     readonly auth: EngineTargetCloudAuth | undefined;
     readonly explicitAddresses?: readonly string[];
 }
-export type SessionDispatchRefusal = 'not-wired' | 'scope-mismatch' | 'scope-unproven' | 'unresolved';
+export type SessionDispatchRefusal = 'not-wired' | 'scope-mismatch' | 'scope-unproven' | 'unresolved' | 'session-ambiguous';
 export type SessionDispatchDecision = {
     readonly kind: 'self';
     readonly wiringSnapshotId: string;
@@ -153,4 +153,5 @@ export declare function sessionEngineBindingFor(input: SessionEngineBindingInput
 export declare function isSessionEngineView(v: {} | null | undefined): boolean;
 export declare function readSessionEngine(record: SessionMapRecord | undefined): SessionEngineReading;
 export declare function commitSessionEngine(store: SessionMapStorePort, session: SessionEngineSessionRef, request: SessionEngineCommitRequest): SessionEngineCommitResult;
+export declare function sessionDispatchRefusedFor(refusal: SessionDispatchRefusal): SessionDispatchRefused;
 export declare function sessionDispatchTarget(reading: SessionEngineReading, ctx: SessionEngineWiring): SessionDispatchDecision;

package/dist/sessionEngine.js

@@ -382,8 +382,13 @@ const REFUSAL_KEYS = {
     'scope-mismatch': 'session.engine.dispatch.scopeMismatch',
     'scope-unproven': 'session.engine.dispatch.scopeUnproven',
     unresolved: 'session.engine.dispatch.unresolved',
+    'session-ambiguous': 'session.engine.dispatch.sessionAmbiguous',
 };
 const refused = (refusal) => Object.freeze({ kind: 'refused', refusal, message: msg(REFUSAL_KEYS[refusal]) });
+export function sessionDispatchRefusedFor(refusal) {
+    const word = Object.keys(REFUSAL_KEYS).find((w) => w === refusal);
+    return refused(word ?? 'unresolved');
+}
 function authOf(ctx) {
     const slot = slotReadOf(ctx, 'auth');
     if (slot.presence === 'absent' || (slot.presence === 'present' && slot.value === undefined))

package/dist/settingsHooksSalvage.d.ts

@@ -40,6 +40,11 @@ export declare function hooksSalvageMaskOf(dropped: readonly {
     readonly path: readonly (string | number)[];
 }[]): HooksSalvageMask;
 export declare function salvageSettingsHooksEntries(doc: SettingsDocument | null | undefined): HooksSalvage;
+export declare function hooksGroupUnreadKeys(event: string, group: object): readonly string[] | undefined;
+export type HooksGroupAuthoredSource = 'absent' | 'present' | 'unreadable';
+export declare function hooksGroupAuthoredSource(group: object): HooksGroupAuthoredSource;
+export declare function hooksEntryUnreadKeys(event: string, entry: object, notRead: readonly string[]): readonly string[] | undefined;
+export declare function hooksKeyCoordinateText(path: readonly (string | number)[]): string;
 export declare const HOOK_SETTINGS_SOURCE_TEXT: Readonly<Record<HookSettingsSource, string>>;
 export declare function layerNotAppliedRefusesTurn(source: HookSettingsSource): boolean;
 export declare function settingsHooksSalvageNotice(salvage: HooksSalvage, source: HookSettingsSource, doc?: SettingsDocument | null): string | undefined;