@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/seatContract.js

@@ -10,6 +10,7 @@ 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
@@ -184,6 +185,21 @@ const R_INT0 = ruleOf("non-negative integer", (v) => typeof v === "number" && Nu
 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()
@@ -293,6 +309,8 @@ const CHROME_ARM_SEAT_ROUTE = {
     compaction_started: "seat",
     compaction_outcome: "seat",
     engine_notice: "seat",
+    subagent_alias: "seat",
+    session_box_notice: "seat",
     workflow_notification_enqueue: "host",
     plan_review_park: "host",
     approval_request: "host",
@@ -381,7 +399,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", "seatActions"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -461,6 +479,8 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     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" }),
+    notificationLevels: Object.freeze({ action: "Choosing notification levels", ability: "keep notification levels", support: "notification-level support" }),
+    modsView: Object.freeze({ action: "Showing mods", ability: "show mods", support: "mods support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -583,6 +603,7 @@ export const SEAT_TURN_SETTINGS_ORIGINS = Object.freeze({
     hooks: Object.freeze({ hostSupplied: "settings.hooks" }),
     resolved: Object.freeze({ hostSupplied: "settings.resolved" }),
     outputStyle: Object.freeze({ hostSupplied: "settings.outputStyle" }),
+    env: Object.freeze({ hostSupplied: "settings.env" }),
 });
 export const SEAT_REWIND_INTENT_KEYS = ["mode", "targetMessageUuid"];
 export const ATTACHMENT_UPLOAD_REQUEST_KEYS = ["name", "mimeType", "bytes"];
@@ -687,6 +708,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) => {
@@ -763,10 +796,80 @@ 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: reqF(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");
+        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(R_ENGINE_LANE),
     generation: reqF(R_INT0),
@@ -794,6 +897,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),
@@ -971,6 +1076,46 @@ const checkSessionMcpPanelResult = seatCheck((v) => {
         return checkSessionMcpPanelFailure(v);
     return Object.hasOwn(v, "scenarioRefusal") ? checkSessionMcpPanelRefusalView(v) : checkSessionMcpPanelServersView(v);
 });
+const MOD_ROW_SKIP = shapeRule("mod skip", {
+    registration: reqF(R_NONEMPTY),
+    cause: reqF(R_NONEMPTY),
+    reason: reqF(R_NONEMPTY),
+});
+const MOD_ROW_MOUNTED_SPEC = {
+    name: reqF(R_NONEMPTY),
+    seat: reqF(R_NONEMPTY),
+    tier: reqF(R_NONEMPTY),
+    provenance: optF(R_NONEMPTY),
+    events: reqF(arrayRule(R_STR)),
+    observe: optF(arrayRule(R_STR)),
+    skipped: optF(arrayRule(MOD_ROW_SKIP, true)),
+};
+const MOD_ROW_REFUSED_SPEC = {
+    name: reqF(R_NONEMPTY),
+    seat: reqF(R_NONEMPTY),
+    tier: reqF(R_NONEMPTY),
+    provenance: optF(R_NONEMPTY),
+    refusedBy: reqF(R_NONEMPTY),
+    reason: reqF(R_NONEMPTY),
+};
+const MOD_ROW = {
+    label: "mod row",
+    test: (v, path) => {
+        if (!isPlainRecord(v))
+            return bad("not object", path);
+        return Object.hasOwn(v, "refusedBy") || Object.hasOwn(v, "reason") ? shapeVerdict(MOD_ROW_REFUSED_SPEC, v, path) : shapeVerdict(MOD_ROW_MOUNTED_SPEC, v, path);
+    },
+};
+const checkSessionModsFailure = seatShapeCheck(armsRule("readSessionMods failure", "kind", {
+    unreadable: DEVICE_UNREADABLE_SPEC,
+    unarmed: {},
+}));
+const checkSessionModsView = seatShapeCheck(shapeRule("mods view", { rows: reqF(arrayRule(MOD_ROW)) }));
+const checkSessionModsResult = seatCheck((v) => {
+    if (!isPlainRecord(v))
+        return bad("not object");
+    return Object.hasOwn(v, "kind") ? checkSessionModsFailure(v) : checkSessionModsView(v);
+});
 const MCP_TOOL_TOGGLE_KEY = shapeRule("toggle key", {
     server: reqF(R_NONEMPTY),
     tool: reqF(R_NONEMPTY),
@@ -1066,6 +1211,75 @@ export function planSetComputerUse(request, lockedByEnv) {
         return Object.freeze({ kind: "refused", reason: "confirmation-required" });
     return Object.freeze({ kind: "apply", enabled: intent.kind === "enable" });
 }
+export const NOTIFICATION_LEVEL_TYPES = Object.freeze(["permission", "question", "idle"]);
+export const NOTIFICATION_LEVELS = Object.freeze(["off", "badge", "banner"]);
+export const NOTIFICATION_LEVEL_REFUSAL_REASONS = Object.freeze(["invalid-request", "unsupported-level", "write-failed"]);
+const R_NOTIFICATION_LEVEL = oneOfRule("notification level", NOTIFICATION_LEVELS);
+const NOTIFICATION_SUPPORTED_ITEMS = arrayRule(R_NOTIFICATION_LEVEL, true);
+const NOTIFICATION_SUPPORTED_ORDER = "bad value (supported levels: off first, closed-set order, no repeats)";
+const R_NOTIFICATION_SUPPORTED = {
+    label: "supported levels",
+    test: (v, path) => {
+        const verdict = NOTIFICATION_SUPPORTED_ITEMS.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rank = (x) => NOTIFICATION_LEVELS.indexOf(x);
+        const rows = ownItems(v);
+        if (rows[0] !== "off")
+            return bad(NOTIFICATION_SUPPORTED_ORDER, path);
+        for (let i = 1; i < rows.length; i += 1)
+            if (rank(rows[i]) <= rank(rows[i - 1]))
+                return bad(NOTIFICATION_SUPPORTED_ORDER, `${path}[${i}]`);
+        return true;
+    },
+};
+const NOTIFICATION_LEVELS_STATE_SHAPE = shapeRule("notification levels state", {
+    levels: reqF(shapeRule("notification levels", {
+        permission: reqF(R_NOTIFICATION_LEVEL),
+        question: reqF(R_NOTIFICATION_LEVEL),
+        idle: reqF(R_NOTIFICATION_LEVEL),
+    })),
+    supported: reqF(R_NOTIFICATION_SUPPORTED),
+});
+const NOTIFICATION_LEVELS_STATE = {
+    label: NOTIFICATION_LEVELS_STATE_SHAPE.label,
+    test: (v, path) => {
+        const verdict = NOTIFICATION_LEVELS_STATE_SHAPE.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        const levels = own(rec, "levels");
+        const supported = ownItems(own(rec, "supported"));
+        for (const t of NOTIFICATION_LEVEL_TYPES)
+            if (!supported.includes(own(levels, t)))
+                return bad("unsupported level", pathAt(path, `levels.${t}`));
+        return true;
+    },
+};
+const checkNotificationLevelsState = seatShapeCheck(NOTIFICATION_LEVELS_STATE);
+const checkSetNotificationLevelResult = seatShapeCheck(okArmsRule("setNotificationLevel result", { state: reqF(NOTIFICATION_LEVELS_STATE) }, {
+    reason: reqF(oneOfRule("notification level refusal", NOTIFICATION_LEVEL_REFUSAL_REASONS)),
+    state: reqF(NOTIFICATION_LEVELS_STATE),
+}));
+export function planSetNotificationLevel(type, level, supported) {
+    if (typeof type !== "string" || !inTuple(NOTIFICATION_LEVEL_TYPES, type) || typeof level !== "string" || !inTuple(NOTIFICATION_LEVELS, level)) {
+        return Object.freeze({ kind: "refused", reason: "invalid-request" });
+    }
+    let delivers = false;
+    try {
+        const n = Array.isArray(supported) ? ownDataField(supported, "length") : undefined;
+        if (typeof n === "number" && Number.isSafeInteger(n) && n <= NOTIFICATION_LEVELS.length) {
+            for (let i = 0; i < n && !delivers; i += 1)
+                delivers = own(supported, String(i)) === level;
+        }
+    }
+    catch {
+        delivers = false;
+    }
+    if (!delivers)
+        return Object.freeze({ kind: "refused", reason: "unsupported-level" });
+    return Object.freeze({ kind: "apply", type, level });
+}
 export const SEAT_ACTION_NAMES = Object.freeze(["new-project", "prefill-composer"]);
 const SEAT_PREFILL_TEXT_MAX = 14336;
 const SEAT_PREFILL_CWD_MAX = 4096;
@@ -1240,11 +1454,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");
@@ -1750,7 +2030,37 @@ export function isSendMessageAck(v) {
 }
 const checkInterruptAck = seatCheck((v) => isPlainRecord(v) && typeof own(v, "interrupted") === "boolean" ? true : bad("interrupt ack needs a plain object with boolean `interrupted`", "interrupted"));
 const checkStopAck = seatCheck((v) => isPlainRecord(v) && typeof own(v, "stopped") === "boolean" ? true : bad("stop ack needs a plain object with boolean `stopped`", "stopped"));
-const checkOkAck = seatCheck((v) => isPlainRecord(v) && typeof own(v, "ok") === "boolean" ? true : bad("ack needs a plain object with boolean `ok`", "ok"));
+const okAckVerdict = (v) => isPlainRecord(v) && typeof own(v, "ok") === "boolean" ? true : bad("ack needs a plain object with boolean `ok`", "ok");
+const checkOkAck = seatCheck(okAckVerdict);
+const TOOL_PERMISSION_SETTLED_WORDS = Object.freeze(["allow", "deny"]);
+const R_SETTLED_ELSEWHERE = shapeRule("settled elsewhere", {
+    firstDecision: reqF(oneOfRule("decision word", TOOL_PERMISSION_SETTLED_WORDS)),
+    contrary: reqF(R_BOOL),
+});
+const checkToolPermissionAck = seatCheck((v) => {
+    const base = okAckVerdict(v);
+    if (base !== true)
+        return base;
+    const slot = own(v, "settledElsewhere");
+    return isAbsent(slot) ? true : R_SETTLED_ELSEWHERE.test(slot, "settledElsewhere");
+});
+const checkSettledElsewhereSlot = seatCheck((v) => R_SETTLED_ELSEWHERE.test(v, "settledElsewhere"));
+export function readToolPermissionSettledElsewhere(ack) {
+    try {
+        if (typeof ack !== "object" || ack === null)
+            return undefined;
+        const slot = own(ack, "settledElsewhere");
+        if (isAbsent(slot))
+            return undefined;
+        if (checkSettledElsewhereSlot(slot) !== true)
+            return undefined;
+        const first = own(slot, "firstDecision");
+        return Object.freeze({ firstDecision: first === "allow" ? "allow" : "deny", contrary: own(slot, "contrary") === true });
+    }
+    catch {
+        return undefined;
+    }
+}
 const checkBooleanAck = (v) => typeof v === "boolean" ? true : bad("expected a bare boolean result");
 const checkGetTranscriptResult = seatCheck((v) => {
     if (!isPlainRecord(v))
@@ -1873,7 +2183,7 @@ export const LOCAL_SESSIONS_SPEC = {
         sendMessage: { kind: "invoke", check: checkSendMessageAck },
         interrupt: { kind: "invoke", check: checkInterruptAck },
         stop: { kind: "invoke", check: checkStopAck },
-        respondToToolPermission: { kind: "invoke", check: checkOkAck },
+        respondToToolPermission: { kind: "invoke", check: checkToolPermissionAck },
         cancelQueuedMessage: { kind: "invoke", check: checkBooleanAck },
         reorderQueuedMessage: { kind: "invoke", check: checkBooleanAck },
         promoteQueuedMessage: { kind: "invoke", check: checkBooleanAck },
@@ -1898,6 +2208,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 },
@@ -1907,7 +2219,10 @@ export const LOCAL_SESSIONS_SPEC = {
         setThinkingLatch: { kind: "invoke", check: checkOkAck },
         getComputerUse: { kind: "invoke", check: checkComputerUseState },
         setComputerUse: { kind: "invoke", check: checkSetComputerUseResult },
+        getNotificationLevels: { kind: "invoke", check: checkNotificationLevelsState },
+        setNotificationLevel: { kind: "invoke", check: checkSetNotificationLevelResult },
         claimSeatActions: { kind: "invoke", check: checkOkAck },
+        readSessionMods: { kind: "invoke", check: checkSessionModsResult },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
         onSeatAction: { kind: "event", check: checkSeatAction },
@@ -1950,6 +2265,8 @@ export const SEAT_METHOD_NAMES = [
     "connectCloudEngine",
     "configureCloudEngine",
     "clearCloudEngine",
+    "answerEngineSwap",
+    "beginSelfUpgrade",
     "listOnboardProviders",
     "probeOnboardEntry",
     "applyOnboardEntry",
@@ -1959,7 +2276,10 @@ export const SEAT_METHOD_NAMES = [
     "setThinkingLatch",
     "getComputerUse",
     "setComputerUse",
+    "getNotificationLevels",
+    "setNotificationLevel",
     "claimSeatActions",
+    "readSessionMods",
     "onEvent",
     "onToolPermissionRequest",
     "onSeatAction",
@@ -2006,6 +2326,12 @@ export const TOOL_PERMISSION_REQUEST_KEYS = [
     "askClass",
     "classes",
     "sessionRow",
+    "probeReason",
+    "probeCause",
+    "feedbackCapable",
+    "requestedBy",
+    "frameReading",
+    "inputSource",
 ];
 export const LOCAL_SESSION_RECORD_KEYS = [
     "sessionId",
@@ -2024,6 +2350,7 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "thinkingLatch",
     "engine",
     "executionLane",
+    "parkedUnresumable",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
     "sessionId",
@@ -2062,13 +2389,14 @@ export const TOOL_PERMISSION_DECISION_KEYS = [
     "answer",
     "updatedInput",
     "remember",
+    "feedback",
 ];
 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: {
@@ -2112,10 +2440,34 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "sessionRow",
                 why: "放宽方向的展示位(CC-699),判官在过境口 toolPermissionRequestAskBits(card, requestId):卡上「本会话放行」判官 standingRowsOf 的会话行同一前提 ∧ 本请求 requestId 的域带得走(live: / durable:),严格 true 才上座、永不铸 false;座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。消费端 `=== true` 才渲「本会话放行」,其余(缺席 / 坏形)一律不渲 —— 缺席是闭合失败,不是「没说就照渲」。不经过境口自铸座位请求的宿主拿不到这一位,座位卡就不给那一档。",
             },
+            {
+                key: "feedbackCapable",
+                why: "放宽方向的展示位(CC-585),判官在过境口 toolPermissionRequestAskBits(card, requestId):卡判官 answerCarriage(card) 答 model(卡带耐久待决行腿的正向事实 parkRow)∧ 本请求 requestId 的域恰是 durable:(只有 /decide 收放行反馈位),严格 true 才上座、永不铸 false;座位门不设第二判官,理由同 sessionRow(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。消费端 `=== true` 才渲「Yes + 告诉 agent 下一步」那一格输入,其余(缺席 / 坏形)一律不渲 —— 缺席是闭合失败。不经过境口自铸座位请求的宿主拿不到这一位,座位卡就不给那一格。",
+            },
             {
                 key: "ruleOffersAbsence",
                 why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
             },
+            {
+                key: "probeReason",
+                why: "展示位(CC-1316),权威窄读在过境口 toolPermissionRequestAskBits,与「为什么问」那一句的读口 askProbeReasonDetail 同一个读点(自有数据属性、取值器不执行;串且去两端空白后非空才在场,原文字节);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形读成缺席 ⇒ 卡上不显示这一句,不改决断;缺席不是「没有原因」。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "probeCause",
+                why: "展示位(CC-1316),与 probeReason 同一对、同一个读点;载体层判(自有数据属性、非 null 非数组对象)才在场,同一引用原样搬运,内部成员不校(成员的窄读归 askProbeReasonDetail / probeCauseRowsOf);座位门不设第二判官,理由同 probeReason。坏形读成缺席 ⇒ 不显示因由行,不改决断。两位按键隔离:一位读不出不连坐另一位。",
+            },
+            {
+                key: "requestedBy",
+                why: "展示位(CC-1341),权威窄读在过境口 toolPermissionRequestAskBits,读点是卡口的唯一载体级读口 approvalRequestedByOf(载体顶层的自有数据属性、取值器不执行;kind 恰 extension 且 name 非空串才在场,出冻结的新铸副本);原始耐久待决行不读(上游不在行上铸这一位);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形读成缺席 ⇒ 卡上不显示发起者行,不改决断;缺席不是「模型发起」。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "frameReading",
+                why: "展示位(CC-1345),权威窄读在过境口 toolPermissionRequestAskBits,读点是包内唯一读口 cardPayloadReadingOf(卡上 cardPayloadUnreadable 严格 true ∧ cardPayloadUnreadableWhy 是判因闭集三词之一才在场;卡面通用卡第一行按因选句同读它);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。表外词 / 游离判因词 / 判因未知读成缺席 ⇒ 卡上回落不分因的原句,不改决断;缺席不是「帧读得出」。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
+            {
+                key: "inputSource",
+                why: "展示位(CC-1366),权威窄读在过境口 toolPermissionRequestAskBits,读点是包内唯一窄读 approvalInputSourceOf(载体顶层的自有数据属性、取值器不执行;闭集 record / stream 两词精确字节才在场);来源位本身只有一个铸点(卡入参读法的读数 → 位),过境口只抄卡上已铸的位、不拿 input 重判来源,原始帧 / 原始耐久待决行直交恒缺席;座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。表外词 / 近义词 / 非串读成缺席 ⇒ 壳按来源不明处置,不改决断;缺席不是 record。不经过境口自铸座位请求的宿主要自己按同一把窄读。",
+            },
         ],
     },
     LocalSessionEvent: {
@@ -2247,6 +2599,11 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         validated: ["ok"],
         unchecked: [],
     },
+    ToolPermissionAck: {
+        check: checkToolPermissionAck,
+        validated: ["ok", "settledElsewhere"],
+        unchecked: [],
+    },
     GetTranscriptResult: {
         check: checkGetTranscriptResult,
         validated: ["sessionId", "messages"],
@@ -2274,7 +2631,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2340,7 +2697,12 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["ComputerUseState", checkComputerUseState],
         ["SetComputerUseResult", checkSetComputerUseResult],
         ["SetComputerUseRequest", checkSetComputerUseRequest],
+        ["NotificationLevelsState", checkNotificationLevelsState],
+        ["SetNotificationLevelResult", checkSetNotificationLevelResult],
         ["SeatAction", checkSeatAction],
+        ["EngineSwapAnswerOutcome", checkEngineSwapAnswerOutcome],
+        ["SelfUpgradeOutcome", checkSelfUpgradeOutcome],
+        ["SessionModsResult", checkSessionModsResult],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2404,5 +2766,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,
 ];
 void _seatContractPins;

package/dist/sessionBackground.js

@@ -6,6 +6,7 @@ import { isLoopbackWireUrl } from './engineWireSdk.js';
 import { hostEnv } from './hostEnv.js';
 import { approvalDecisionHolds } from './hitl/approvalHolds.js';
 import { readRunTerminal } from './runTerminal.js';
+import { isReplayedTerminal } from './replayBody.js';
 import { appendOwnElement, ownDataField, putOwnKey, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { msg, renderMessage } from './i18n/translate.js';
 export function projectSessionBackgroundable(caps) {
@@ -34,6 +35,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';
@@ -416,7 +419,7 @@ function observeFrame(rec, ev) {
         }
         else {
             rec.phase = 'ended-unstarted';
-            rec.replay = type === 'done' && frameSlot(ev, 'replay') === true;
+            rec.replay = type === 'done' && isReplayedTerminal(ev);
         }
         return;
     }

package/dist/sessionBackgroundHandoff.js

@@ -4,6 +4,7 @@ import { REATTACH_WINDOW_MS, reattachBackoffMs } from './reattachWindow.js';
 import { terminalEventFromRunRow } from './headlessReconnectWire.js';
 import { RUN_CANCELLED_CODE } from './runCancelContext.js';
 import { readRunTerminal } from './runTerminal.js';
+import { isReplayedTerminal } from './replayBody.js';
 import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { backgroundHandoffSentence, judgeHandoff, ownSlotOf, wireStateOf, } from './sessionBackground.js';
 export const BACKGROUND_HANDOFF_ABORT_REASON = 'background';
@@ -34,7 +35,7 @@ function executionSettlementOf(ev) {
                 return { runEnded: true, kind: 'cancelled', status: 'failed' };
             return { runEnded: true, kind: 'failed', status: 'failed', ...(code !== undefined ? { errorCode: code } : {}) };
         }
-        if (type !== 'done' || slot(ev, 'replay') === true)
+        if (type !== 'done' || isReplayedTerminal(ev))
             return undefined;
         const read = readRunTerminal(slot(ev, 'result'));
         if (read === null)

package/dist/sessionEngine.d.ts

@@ -153,5 +153,7 @@ 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 type SessionEngineRepointResult = 'moved' | 'unaffected' | 'conflict' | 'unreadable' | 'store-failed' | 'request-invalid';
+export declare function repointSessionEngine(store: SessionMapStorePort, from: string, to: string): SessionEngineRepointResult;
 export declare function sessionDispatchRefusedFor(refusal: SessionDispatchRefusal): SessionDispatchRefused;
 export declare function sessionDispatchTarget(reading: SessionEngineReading, ctx: SessionEngineWiring): SessionDispatchDecision;