@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/seatContract.js

@@ -1,4 +1,5 @@
 import { PERMISSION_MODE_WORDS, REASONING_EFFORT_WORDS } from "./taskRequestWords.js";
+import { CC_TOOL_DENIAL_KINDS } from "./gateVocabulary.js";
 import { liveDefaultModelCopy, liveModelRowCopy } from "./model/liveCatalogShape.js";
 import { REWIND_MODES } from "./rewindWireCaps.js";
 import { SETTINGS_MODEL_API_WORDS } from "./generated/settingsSchemaTables.js";
@@ -11,6 +12,10 @@ import { THINKING_LATCH_EVENTS, THINKING_LATCH_ROW_WORDS } from "./thinkingLatch
 import { EXECUTION_PLACEMENT_ROLES } from "./executionPlacementWords.js";
 import { isSessionEngineView } from "./sessionEngine.js";
 import { LOCAL_ENGINE_SWAP_CAUSES } from "./localEngineSwapCard.js";
+import { HOOK_ENTRY_TYPE_WORDS, PLUGIN_HOOK_EXCLUSION_REASONS, PLUGIN_HOOK_REASONS, SETTINGS_HOOK_DROP_REASONS, } from "./pluginHooksWire.js";
+import { HTTP_POLICY_DROP_REASONS } from "./httpHookPolicy.js";
+import { HOOK_SETTINGS_SOURCE_TEXT } from "./settingsHooksSalvage.js";
+import { SETTINGS_HOOK_EVENTS, SETTINGS_HOOKS_DROPPED_PIECE_CODES, SETTINGS_HOOKS_REJECTION_CODES } from "./generated/settingsSchemaFns.js";
 const bad = (reason, field) => field === undefined ? { reason } : { reason, field };
 const nested = (prefix, verdict) => {
     const path = verdict.field === undefined
@@ -310,6 +315,9 @@ const CHROME_ARM_SEAT_ROUTE = {
     compaction_outcome: "seat",
     engine_notice: "seat",
     subagent_alias: "seat",
+    session_box_notice: "seat",
+    resupply_truncated: "seat",
+    host_setting_notice: "seat",
     workflow_notification_enqueue: "host",
     plan_review_park: "host",
     approval_request: "host",
@@ -398,7 +406,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", "quickEntryShortcut", "hooksRoster"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -478,6 +486,10 @@ 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" }),
+    quickEntryShortcut: Object.freeze({ action: "Changing the Quick Entry shortcut", ability: "change the Quick Entry shortcut", support: "Quick Entry shortcut support" }),
+    hooksRoster: Object.freeze({ action: "Showing hooks", ability: "show hooks", support: "hooks support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -600,6 +612,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"];
@@ -711,6 +724,7 @@ export const LOCAL_ENGINE_DOWN_REASONS = Object.freeze([
     "stop-failed",
     "crash-loop",
     "high-water-unreadable",
+    "exited-once",
     "principal-unknown",
 ]);
 export const LOCAL_ENGINE_WAITING_REASONS = Object.freeze(["starting", "dormant", "draining", "unanswered", "peer"]);
@@ -845,7 +859,7 @@ 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),
+    lifecycle: reqF(LOCAL_ENGINE_SEAT_READING),
 };
 const ENGINE_TARGET_LOCAL = {
     label: "local",
@@ -855,8 +869,6 @@ const ENGINE_TARGET_LOCAL = {
             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"))
@@ -872,7 +884,7 @@ const ENGINE_TARGET_STATE = shapeRule("engine target", {
     mode: reqF(R_ENGINE_LANE),
     generation: reqF(R_INT0),
     cloud: reqF(ENGINE_TARGET_CLOUD),
-    local: reqF(ENGINE_TARGET_LOCAL),
+    local: optF(ENGINE_TARGET_LOCAL),
 });
 const checkEngineTargetState = seatShapeCheck(ENGINE_TARGET_STATE);
 const okArmsRule = (label, okSpec, refusedSpec) => ({
@@ -1074,6 +1086,118 @@ 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);
+});
+export const SESSION_HOOKS_ROSTER_STATUSES = Object.freeze(["engine", "shell", "not_run"]);
+const HOOKS_ROSTER_CLOSED_BY = Object.freeze(["workspace_untrusted", "governance_unreadable", "policy_disable_all"]);
+const HOOKS_ROSTER_REASONS = Object.freeze([...new Set([...PLUGIN_HOOK_REASONS, ...PLUGIN_HOOK_EXCLUSION_REASONS, ...SETTINGS_HOOK_DROP_REASONS])]);
+const R_HOOK_SOURCE = ruleOf("hook source", (v) => typeof v === "string" && Object.hasOwn(HOOK_SETTINGS_SOURCE_TEXT, v));
+const R_HOOK_EVENT = oneOfRule("hook event", SETTINGS_HOOK_EVENTS);
+const HOOKS_ROSTER_ROW_SHAPE = shapeRule("hooks roster row", {
+    source: reqF(R_HOOK_SOURCE),
+    event: reqF(R_HOOK_EVENT),
+    groupIndex: reqF(R_INT0),
+    hookIndex: reqF(R_INT0),
+    type: optF(oneOfRule("hook type", HOOK_ENTRY_TYPE_WORDS)),
+    status: reqF(oneOfRule("hooks roster status", SESSION_HOOKS_ROSTER_STATUSES)),
+    reason: reqF(oneOfRule("hooks roster reason", HOOKS_ROSTER_REASONS)),
+});
+const HOOKS_ROSTER_ROW = {
+    label: HOOKS_ROSTER_ROW_SHAPE.label,
+    test: (v, path) => {
+        const verdict = HOOKS_ROSTER_ROW_SHAPE.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        const status = own(rec, "status");
+        const reason = own(rec, "reason");
+        if (status === "engine" && !PLUGIN_HOOK_REASONS.includes(reason))
+            return bad("status conflict", pathAt(path, "reason"));
+        return true;
+    },
+};
+const HOOKS_ROSTER_LAYER = armsRule("hooks roster layer", "state", {
+    "loaded-partial": { source: reqF(R_HOOK_SOURCE), codes: reqF(arrayRule(oneOfRule("hooks drop code", SETTINGS_HOOKS_DROPPED_PIECE_CODES), true)) },
+    rejected: { source: reqF(R_HOOK_SOURCE), codes: reqF(arrayRule(oneOfRule("hooks rejection code", SETTINGS_HOOKS_REJECTION_CODES), true)) },
+    trust_withheld: { source: reqF(R_HOOK_SOURCE) },
+});
+const HOOKS_ROSTER_HTTP_ROW = shapeRule("hooks roster http row", {
+    source: reqF(R_HOOK_SOURCE),
+    event: reqF(R_HOOK_EVENT),
+    reason: reqF(oneOfRule("http policy reason", HTTP_POLICY_DROP_REASONS)),
+});
+const HOOKS_ROSTER_SHAPE = shapeRule("hooks roster", {
+    closedBy: reqF(ruleOf("closedBy", (v) => v === null || (typeof v === "string" && inTuple(HOOKS_ROSTER_CLOSED_BY, v)))),
+    sources: optF(arrayRule(R_HOOK_SOURCE)),
+    rows: reqF(arrayRule(HOOKS_ROSTER_ROW)),
+    layers: reqF(arrayRule(HOOKS_ROSTER_LAYER)),
+    http: reqF(arrayRule(HOOKS_ROSTER_HTTP_ROW)),
+    unlisted: reqF(R_INT0),
+});
+const checkSessionHooksRosterView = seatShapeCheck({
+    label: HOOKS_ROSTER_SHAPE.label,
+    test: (v, path) => {
+        const verdict = HOOKS_ROSTER_SHAPE.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        if (own(rec, "closedBy") === null)
+            return true;
+        const rows = ownItems(own(rec, "rows"));
+        for (let i = 0; i < rows.length; i += 1) {
+            if (own(rows[i], "status") !== "not_run")
+                return bad("status conflict", pathAt(path, `rows[${i}].status`));
+        }
+        return true;
+    },
+});
+const checkSessionHooksRosterFailure = seatShapeCheck(armsRule("readSessionHooksRoster failure", "kind", {
+    unreadable: DEVICE_UNREADABLE_SPEC,
+    unarmed: {},
+}));
+const checkSessionHooksRosterResult = seatCheck((v) => {
+    if (!isPlainRecord(v))
+        return bad("not object");
+    return Object.hasOwn(v, "kind") ? checkSessionHooksRosterFailure(v) : checkSessionHooksRosterView(v);
+});
 const MCP_TOOL_TOGGLE_KEY = shapeRule("toggle key", {
     server: reqF(R_NONEMPTY),
     tool: reqF(R_NONEMPTY),
@@ -1169,7 +1293,144 @@ 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"]);
+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 QUICK_ENTRY_SHORTCUT_FAILURES = Object.freeze(["invalid-accelerator", "registration-failed"]);
+export const QUICK_ENTRY_SHORTCUT_REFUSAL_REASONS = Object.freeze(["invalid-request", "invalid-accelerator", "registration-failed", "write-failed"]);
+const QUICK_ENTRY_ACCELERATOR_SPEC = { accelerator: reqF(R_NONEMPTY) };
+const R_QUICK_ENTRY_SHORTCUT = {
+    label: "quick entry shortcut",
+    test: (v, path) => (v === "off" ? true : shapeVerdict(QUICK_ENTRY_ACCELERATOR_SPEC, v, path)),
+};
+const QUICK_ENTRY_STATE_SHAPE = shapeRule("quick entry shortcut state", {
+    saved: reqF(R_QUICK_ENTRY_SHORTCUT),
+    active: reqF(ruleOf("active accelerator", (v) => v === null || (typeof v === "string" && v.length > 0))),
+    savedFailure: reqF(ruleOf("saved failure", (v) => v === null || (typeof v === "string" && inTuple(QUICK_ENTRY_SHORTCUT_FAILURES, v)))),
+});
+const QUICK_ENTRY_STATE = {
+    label: QUICK_ENTRY_STATE_SHAPE.label,
+    test: (v, path) => {
+        const verdict = QUICK_ENTRY_STATE_SHAPE.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        if (own(rec, "savedFailure") === null)
+            return true;
+        const saved = own(rec, "saved");
+        if (saved === "off")
+            return bad("failure conflict", pathAt(path, "savedFailure"));
+        if (own(rec, "active") === own(saved, "accelerator"))
+            return bad("failure conflict", pathAt(path, "active"));
+        return true;
+    },
+};
+const checkQuickEntryShortcutState = seatShapeCheck(QUICK_ENTRY_STATE);
+const SET_QUICK_ENTRY_SHORTCUT_RESULT = okArmsRule("setQuickEntryShortcut result", { state: reqF(QUICK_ENTRY_STATE) }, {
+    reason: reqF(oneOfRule("quick entry refusal", QUICK_ENTRY_SHORTCUT_REFUSAL_REASONS)),
+    state: reqF(QUICK_ENTRY_STATE),
+});
+const checkSetQuickEntryShortcutResult = seatShapeCheck({
+    label: SET_QUICK_ENTRY_SHORTCUT_RESULT.label,
+    test: (v, path) => {
+        const verdict = SET_QUICK_ENTRY_SHORTCUT_RESULT.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        if (own(rec, "ok") === true && own(own(rec, "state"), "savedFailure") !== null)
+            return bad("failure conflict", pathAt(path, "state.savedFailure"));
+        return true;
+    },
+});
+export function planSetQuickEntryShortcut(request) {
+    const refused = Object.freeze({ kind: "refused", reason: "invalid-request" });
+    if (request === "off")
+        return Object.freeze({ kind: "apply", next: "off" });
+    try {
+        if (!isPlainRecord(request) || firstAccessorPath(request) !== undefined)
+            return refused;
+        const snap = new Map();
+        for (const k of Reflect.ownKeys(request))
+            if (typeof k === "string")
+                snap.set(k, own(request, k));
+        if (snap.size !== 1 || !snap.has("accelerator"))
+            return refused;
+        const accelerator = snap.get("accelerator");
+        if (typeof accelerator !== "string" || accelerator.length === 0)
+            return refused;
+        return Object.freeze({ kind: "apply", next: Object.freeze({ accelerator }) });
+    }
+    catch {
+        return refused;
+    }
+}
+export const SEAT_ACTION_NAMES = Object.freeze(["new-project", "prefill-composer", "open-local-setup"]);
 const SEAT_PREFILL_TEXT_MAX = 14336;
 const SEAT_PREFILL_CWD_MAX = 4096;
 const SEAT_ACTIONS_CLAIM_MAX = 16;
@@ -1182,6 +1443,7 @@ const R_PREFILL_CWD = ruleOf(`folder path (1–${SEAT_PREFILL_CWD_MAX} chars, no
 const SEAT_ACTION_ARMS = {
     "new-project": {},
     "prefill-composer": { text: reqF(R_PREFILL_TEXT), cwd: optF(R_PREFILL_CWD) },
+    "open-local-setup": {},
 };
 export const checkSeatAction = seatShapeCheck(armsRule("seat action", "action", SEAT_ACTION_ARMS));
 const seatActionMalformed = (reason) => Object.freeze({ kind: "malformed", reason });
@@ -1200,6 +1462,8 @@ export function readSeatAction(ev) {
         }
         if (name === "new-project")
             return Object.freeze({ kind: "action", action: Object.freeze({ action: "new-project" }) });
+        if (name === "open-local-setup")
+            return Object.freeze({ kind: "action", action: Object.freeze({ action: "open-local-setup" }) });
         const text = own(ev, "text");
         const cwd = own(ev, "cwd");
         if (R_PREFILL_TEXT.test(text, "text") !== true || typeof text !== "string")
@@ -1652,6 +1916,8 @@ const SUBAGENT_CONTENT_SHAPE = shapeRule("subagent content", {
     output: optF(R_STR),
     isError: optF(R_BOOL),
     notExecuted: optF(R_TRUE),
+    denialKind: optF(oneOfRule("denial kind", CC_TOOL_DENIAL_KINDS)),
+    refusalNoted: optF(R_TRUE),
 });
 export function readSeatSubagentContent(event) {
     try {
@@ -1919,7 +2185,73 @@ 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 TOOL_PERMISSION_UNCONFIRMED_CAUSES = Object.freeze(["transport", "server_error", "local_error", "aborted", "gone_after_retry", "registry_unreadable"]);
+const R_UNCONFIRMED = shapeRule("unconfirmed", {
+    cause: reqF(oneOfRule("cause word", TOOL_PERMISSION_UNCONFIRMED_CAUSES)),
+});
+const R_TOOL_PERMISSION_ACK = shapeRule("permission ack", {
+    ok: reqF(R_BOOL),
+    settledElsewhere: optF(R_SETTLED_ELSEWHERE),
+    unconfirmed: optF(R_UNCONFIRMED),
+});
+const TOOL_PERMISSION_ACK_SLOTS = [["settledElsewhere"], ["unconfirmed"]];
+const R_FALSE = ruleOf("false", (v) => v === false);
+function toolPermissionAckVerdict(v) {
+    if (!isPlainRecord(v))
+        return okAckVerdict(v);
+    const shape = R_TOOL_PERMISSION_ACK.test(v, "");
+    if (shape !== true)
+        return shape;
+    const ack = v;
+    const groups = keyGroupsVerdict(TOOL_PERMISSION_ACK_SLOTS, ack, "");
+    if (groups !== true)
+        return groups;
+    const ok = own(ack, "ok");
+    if (!isAbsent(own(ack, "unconfirmed")))
+        return R_FALSE.test(ok, "ok");
+    const settled = own(ack, "settledElsewhere");
+    if (isAbsent(settled))
+        return true;
+    return own(settled, "contrary") === true ? R_FALSE.test(ok, "ok") : R_TRUE.test(ok, "ok");
+}
+const checkToolPermissionAck = seatShapeCheck({ label: "permission ack", test: (v) => toolPermissionAckVerdict(v) });
+export function readToolPermissionSettledElsewhere(ack) {
+    try {
+        if (checkToolPermissionAck(ack) !== true)
+            return undefined;
+        const slot = own(ack, "settledElsewhere");
+        if (isAbsent(slot))
+            return undefined;
+        const first = own(slot, "firstDecision");
+        return Object.freeze({ firstDecision: first === "allow" ? "allow" : "deny", contrary: own(slot, "contrary") === true });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readToolPermissionAckState(ack) {
+    try {
+        if (checkToolPermissionAck(ack) !== true)
+            return undefined;
+        const un = own(ack, "unconfirmed");
+        if (!isAbsent(un)) {
+            const word = own(un, "cause");
+            const cause = TOOL_PERMISSION_UNCONFIRMED_CAUSES.find((w) => w === word);
+            return cause === undefined ? undefined : Object.freeze({ kind: "unconfirmed", cause });
+        }
+        return own(ack, "ok") === true ? Object.freeze({ kind: "applied" }) : Object.freeze({ kind: "not_applied" });
+    }
+    catch {
+        return undefined;
+    }
+}
 const checkBooleanAck = (v) => typeof v === "boolean" ? true : bad("expected a bare boolean result");
 const checkGetTranscriptResult = seatCheck((v) => {
     if (!isPlainRecord(v))
@@ -2042,7 +2374,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 },
@@ -2078,7 +2410,13 @@ 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 },
+        getQuickEntryShortcut: { kind: "invoke", check: checkQuickEntryShortcutState },
+        setQuickEntryShortcut: { kind: "invoke", check: checkSetQuickEntryShortcutResult },
         claimSeatActions: { kind: "invoke", check: checkOkAck },
+        readSessionMods: { kind: "invoke", check: checkSessionModsResult },
+        readSessionHooksRoster: { kind: "invoke", check: checkSessionHooksRosterResult },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
         onSeatAction: { kind: "event", check: checkSeatAction },
@@ -2132,7 +2470,13 @@ export const SEAT_METHOD_NAMES = [
     "setThinkingLatch",
     "getComputerUse",
     "setComputerUse",
+    "getNotificationLevels",
+    "setNotificationLevel",
+    "getQuickEntryShortcut",
+    "setQuickEntryShortcut",
     "claimSeatActions",
+    "readSessionMods",
+    "readSessionHooksRoster",
     "onEvent",
     "onToolPermissionRequest",
     "onSeatAction",
@@ -2179,6 +2523,12 @@ export const TOOL_PERMISSION_REQUEST_KEYS = [
     "askClass",
     "classes",
     "sessionRow",
+    "probeReason",
+    "probeCause",
+    "feedbackCapable",
+    "requestedBy",
+    "frameReading",
+    "inputSource",
 ];
 export const LOCAL_SESSION_RECORD_KEYS = [
     "sessionId",
@@ -2236,6 +2586,7 @@ 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 = {
@@ -2286,10 +2637,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: {
@@ -2421,6 +2796,11 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         validated: ["ok"],
         unchecked: [],
     },
+    ToolPermissionAck: {
+        check: checkToolPermissionAck,
+        validated: ["ok", "settledElsewhere", "unconfirmed"],
+        unchecked: [],
+    },
     GetTranscriptResult: {
         check: checkGetTranscriptResult,
         validated: ["sessionId", "messages"],
@@ -2448,7 +2828,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", "quickEntryShortcut", "hooksRoster"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2514,9 +2894,15 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["ComputerUseState", checkComputerUseState],
         ["SetComputerUseResult", checkSetComputerUseResult],
         ["SetComputerUseRequest", checkSetComputerUseRequest],
+        ["NotificationLevelsState", checkNotificationLevelsState],
+        ["SetNotificationLevelResult", checkSetNotificationLevelResult],
         ["SeatAction", checkSeatAction],
         ["EngineSwapAnswerOutcome", checkEngineSwapAnswerOutcome],
         ["SelfUpgradeOutcome", checkSelfUpgradeOutcome],
+        ["SessionModsResult", checkSessionModsResult],
+        ["QuickEntryShortcutState", checkQuickEntryShortcutState],
+        ["SetQuickEntryShortcutResult", checkSetQuickEntryShortcutResult],
+        ["SessionHooksRosterResult", checkSessionHooksRosterResult],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2581,5 +2967,11 @@ 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, 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) {
@@ -418,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)