@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/seatContract.js

@@ -1,16 +1,28 @@
 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";
 import { PROBE_VERDICTS } from "./modelCapabilityProbe.js";
+import { MODEL_POOL_CHANNEL_SOURCES, MODEL_POOL_COMPLETENESS, MODEL_POOL_MAX_BATCH, MODEL_POOL_PROBE_STATES } from "./localConfig/modelPoolWords.js";
+import { LOCAL_CONFIG_REFUSALS } from "./localConfig/kernel.js";
+import { localConfigDisclosureShapeOf, localConfigReceiptShapeOf, localConfigUnavailableShapeOf } from "./localConfig/receiptShape.js";
+import { TIER_ORDER } from "./model/tierVocabulary.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 { checkMcpServerReportView, checkMcpServerEditOutcomeView, checkMcpServerProbeView } from "./localConfig/mcp/views.js";
 import { THINKING_LATCH_EVENTS, THINKING_LATCH_ROW_WORDS } from "./thinkingLatchWords.js";
+import { SKILLS_VIEW_EXCLUDED_REASONS, SKILLS_VIEW_LAYERS } from "./localConfig/skillsWords.js";
+import { SKILL_OVERRIDE_DECIDERS, SKILL_OVERRIDE_LOCK_SOURCES, SKILL_OVERRIDE_STATES } from "./skillOverrideChain.js";
 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
@@ -311,6 +323,8 @@ const CHROME_ARM_SEAT_ROUTE = {
     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",
@@ -399,7 +413,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", "notificationLevels", "modsView"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView", "quickEntryShortcut", "hooksRoster", "mcpServers", "mcpServerEdit", "skills", "skillsEdit", "modelPool", "modelPoolEdit"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -481,6 +495,14 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     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" }),
+    mcpServers: Object.freeze({ action: "Listing MCP servers", ability: "list MCP servers", support: "MCP server listing" }),
+    mcpServerEdit: Object.freeze({ action: "Editing MCP servers", ability: "edit MCP servers", support: "MCP server editing" }),
+    skills: Object.freeze({ action: "Showing skills", ability: "show skills", support: "skills support" }),
+    skillsEdit: Object.freeze({ action: "Changing skills", ability: "change skills", support: "skill editing support" }),
+    modelPool: Object.freeze({ action: "Showing your models", ability: "show your models", support: "model list support" }),
+    modelPoolEdit: Object.freeze({ action: "Editing your models", ability: "edit your models", support: "model editing support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -715,6 +737,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"]);
@@ -874,7 +897,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) => ({
@@ -929,6 +952,7 @@ const ONBOARD_PROBE_RESULT = shapeRule("probe result", {
     verdict: reqF(oneOfRule("probe verdict", PROBE_VERDICTS)),
     detail: reqF(R_STR),
     thinking: optF(R_NONEMPTY),
+    firstOutputMs: optF(R_INT0),
 });
 const ENGINE_UP_SPEC = { model: reqF(ruleOf("string|null", (x) => x === null || typeof x === "string")) };
 const ENGINE_NOT_UP_SPEC = { reason: reqF(R_STR) };
@@ -992,6 +1016,7 @@ const checkOnboardProvidersResult = seatShapeCheck(shapeRule("onboard providers"
             maxTokens: reqF(R_INT1),
         }))),
         consoleUrl: optF(R_STR),
+        signupUrl: optF(R_STR),
     }))),
     importable: optF(arrayRule(shapeRule("importable profile", {
         id: reqF(R_NONEMPTY),
@@ -1003,6 +1028,148 @@ const checkOnboardProvidersResult = seatShapeCheck(shapeRule("onboard providers"
         isCurrent: optF(R_BOOL),
     }))),
 }));
+const R_TIER = oneOfRule("tier", TIER_ORDER);
+const R_CREDENTIAL = armsRule("credential", "kind", { key: { apiKey: reqF(R_NONEMPTY) }, none: {} });
+const R_TIER_MAP = ruleOf("tier map", (v) => isPlainRecord(v) && Object.keys(v).every((k) => TIER_ORDER.includes(k) && typeof own(v, k) === "string"));
+const R_NULLABLE_STR = ruleOf("string|null", (v) => v === null || typeof v === "string");
+const R_NULLABLE_BOOL = ruleOf("boolean|null", (v) => v === null || typeof v === "boolean");
+const SEAT_POOL_ENTRY = shapeRule("pool entry", {
+    modelId: reqF(R_NONEMPTY),
+    api: reqF(R_API_WORD),
+    baseUrl: reqF(R_NONEMPTY),
+    credential: reqF(R_CREDENTIAL),
+    label: optF(R_STR),
+    vision: optF(R_BOOL),
+    contextWindow: optF(R_INT1),
+    maxTokens: optF(R_INT1),
+    channel: optF(R_NONEMPTY),
+    acceptUnverified: optF(R_BOOL),
+});
+const SEAT_POOL_EDIT = armsRule("pool edit", "kind", {
+    add: { entries: reqF(arrayRule(SEAT_POOL_ENTRY, true)), defaultIndex: optF(R_INT0) },
+    update: { name: reqF(R_NONEMPTY), label: optF(R_NULLABLE_STR), vision: optF(R_NULLABLE_BOOL), contextWindow: optF(R_INT1), maxTokens: optF(R_INT1) },
+    remove: { name: reqF(R_NONEMPTY) },
+    setDefault: { name: reqF(R_NONEMPTY) },
+    importEnvModels: {},
+    importChannel: {
+        source: reqF(oneOfRule("channel source", MODEL_POOL_CHANNEL_SOURCES)),
+        profileId: reqF(R_NONEMPTY),
+        modelIds: reqF(arrayRule(R_NONEMPTY, true)),
+        defaultIndex: optF(R_INT0),
+        acceptUnverified: optF(R_BOOL),
+    },
+    bindTier: { group: reqF(R_NONEMPTY), tier: reqF(R_TIER), name: reqF(R_NULLABLE_STR) },
+    switchTierGroup: { group: reqF(R_NONEMPTY) },
+    addTierGroup: { group: reqF(R_NONEMPTY), tiers: optF(R_TIER_MAP) },
+    removeTierGroup: { group: reqF(R_NONEMPTY) },
+    migrateTierGroups: {},
+    sweepOrphanKeySlots: {},
+});
+const POOL_EDIT_KEY_ALLOW = new Set(Array.from({ length: MODEL_POOL_MAX_BATCH }, (_, i) => `edit.entries[${i}].credential.apiKey`));
+export const checkModelPoolEditRequest = seatShapeCheck(shapeRule("editModelPool request", { edit: reqF(SEAT_POOL_EDIT), dryRun: optF(R_BOOL) }), POOL_EDIT_KEY_ALLOW);
+export const checkModelDiscoveryRequest = seatShapeCheck(shapeRule("discoverModels request", { source: reqF(ONBOARD_SOURCE), baseUrl: optF(R_NONEMPTY), api: optF(R_API_WORD), apiKey: optF(R_NONEMPTY) }), ONBOARD_KEY_ALLOW);
+const leafVerdict = (r) => (r === true ? true : bad(r.reason, r.field));
+const leafRule = (label, judge) => ({
+    label,
+    test: (v, path) => leafVerdict(judge(v, path)),
+});
+const R_DISCLOSURE = leafRule("disclosure", localConfigDisclosureShapeOf);
+const R_LOCAL_CONFIG_RECEIPT = leafRule("receipt", localConfigReceiptShapeOf);
+const localConfigListCheck = (view) => seatCheck((v) => {
+    if (!isPlainRecord(v))
+        return bad("not object");
+    return own(v, "kind") === "unavailable" ? leafVerdict(localConfigUnavailableShapeOf(v)) : view(v);
+});
+const R_POOL_PROBLEM = shapeRule("pool problem", {
+    reason: reqF(oneOfRule("refusal", LOCAL_CONFIG_REFUSALS)),
+    detail: reqF(R_STR),
+    index: optF(R_INT0),
+    name: optF(R_NONEMPTY),
+});
+const R_PROBE_STATE = oneOfRule("probe state", MODEL_POOL_PROBE_STATES);
+const R_PLANNED_ENTRY = shapeRule("planned entry", {
+    name: reqF(R_NONEMPTY),
+    modelId: reqF(R_NONEMPTY),
+    keyEnv: reqF(ruleOf("string|null", (v) => v === null || (typeof v === "string" && v.length > 0))),
+    updatedExisting: reqF(R_BOOL),
+    probe: reqF(R_PROBE_STATE),
+});
+const R_DELETE_WARNING = shapeRule("delete warning", { kind: reqF(oneOfRule("warning kind", ["allowlist-empties", "tier-binding"])), consequence: reqF(R_NONEMPTY) });
+const R_DELETE_BLOCKER = shapeRule("delete blocker", {
+    kind: reqF(oneOfRule("blocker kind", ["default", "roles", "roster", "unreadable"])),
+    where: reqF(R_NONEMPTY),
+    fix: reqF(R_NONEMPTY),
+});
+const R_CATALOG_ISSUE = shapeRule("catalog issue", { name: reqF(R_NONEMPTY), modelId: reqF(R_STR), issue: reqF(R_NONEMPTY) });
+const checkModelPoolEditResult = seatShapeCheck(shapeRule("editModelPool result", {
+    receipt: reqF(R_LOCAL_CONFIG_RECEIPT),
+    problems: optF(arrayRule(R_POOL_PROBLEM, true)),
+    entries: optF(arrayRule(R_PLANNED_ENTRY, true)),
+    warnings: optF(arrayRule(R_DELETE_WARNING, true)),
+    otherIssues: optF(arrayRule(R_CATALOG_ISSUE, true)),
+    engine: optF(ENGINE_RESTART_OUTCOME),
+}));
+const R_VIEW_ENTRY = shapeRule("pool view entry", {
+    name: reqF(R_NONEMPTY),
+    modelId: reqF(R_NONEMPTY),
+    api: reqF(R_STR),
+    baseUrl: reqF(R_STR),
+    enabled: reqF(R_BOOL),
+    label: optF(R_STR),
+    vision: reqF(shapeRule("vision", { source: reqF(oneOfRule("vision source", ["entry", "family", "unknown"])), value: optF(R_BOOL) })),
+    keyless: reqF(R_BOOL),
+    keyEnv: optF(R_NONEMPTY),
+    contextWindow: optF(R_INT1),
+    maxTokens: optF(R_INT1),
+    probe: reqF(R_PROBE_STATE),
+    probeVerdict: optF(R_NONEMPTY),
+    probedAt: optF(R_NUM),
+    isDefault: reqF(R_BOOL),
+    tiers: reqF(arrayRule(shapeRule("bound tier", { group: reqF(R_NONEMPTY), tier: reqF(R_TIER) }))),
+    deleteBlockers: reqF(arrayRule(R_DELETE_BLOCKER)),
+    deleteWarnings: reqF(arrayRule(R_DELETE_WARNING)),
+    credentialIssue: optF(R_NONEMPTY),
+});
+const R_DEFAULT_MODEL = armsRule("default model", "kind", {
+    named: {
+        name: reqF(R_NONEMPTY),
+        source: reqF(R_NONEMPTY),
+        dangling: reqF(arrayRule(shapeRule("dangling", { source: reqF(R_NONEMPTY), name: reqF(R_STR) }))),
+        disclosures: reqF(arrayRule(R_DISCLOSURE)),
+    },
+    select: {
+        select: reqF(shapeRule("select", { tier: optF(R_STR), needs: optF(arrayRule(R_STR)), prefer: optF(R_STR) })),
+        disclosures: reqF(arrayRule(R_DISCLOSURE)),
+    },
+    none: { disclosures: reqF(arrayRule(R_DISCLOSURE)) },
+    unknown: { disclosures: reqF(arrayRule(R_DISCLOSURE)) },
+});
+const R_POOL_VIEW = shapeRule("pool view", {
+    catalog: reqF(oneOfRule("catalog", ["read", "absent", "unreadable"])),
+    completeness: reqF(oneOfRule("completeness", MODEL_POOL_COMPLETENESS)),
+    unreadableRows: reqF(R_INT0),
+    entries: reqF(arrayRule(R_VIEW_ENTRY)),
+    roles: reqF(arrayRule(shapeRule("role", { role: reqF(R_NONEMPTY), model: optF(R_NONEMPTY), select: optF(R_TRUE) }))),
+    tierGroups: reqF(arrayRule(shapeRule("tier group", { name: reqF(R_NONEMPTY), active: reqF(R_BOOL), tiers: reqF(R_TIER_MAP), resolved: reqF(R_TIER_MAP) }))),
+    activeTierGroup: optF(R_NONEMPTY),
+    defaultModel: reqF(R_DEFAULT_MODEL),
+    legacyTierSettings: reqF(R_BOOL),
+    orphanKeySlots: reqF(R_INT0),
+    envModels: reqF(arrayRule(R_NONEMPTY)),
+    providers: reqF(arrayRule(shapeRule("pool provider", {
+        id: reqF(R_NONEMPTY),
+        name: reqF(R_NONEMPTY),
+        baseUrl: reqF(R_NONEMPTY),
+        api: reqF(R_API_WORD),
+        authEnv: reqF(R_STR),
+        consoleUrl: optF(R_STR),
+        signupUrl: optF(R_STR),
+        keyOptional: reqF(R_BOOL),
+        models: reqF(arrayRule(shapeRule("provider model", { id: reqF(R_NONEMPTY), contextWindow: reqF(R_INT1), maxTokens: reqF(R_INT1) }))),
+    }))),
+});
+const checkModelPoolListResult = localConfigListCheck(seatShapeCheck(R_POOL_VIEW));
+const checkModelDiscoveryResult = seatShapeCheck(okArmsRule("discoverModels result", { candidates: reqF(arrayRule(shapeRule("candidate", { id: reqF(R_NONEMPTY), contextWindow: optF(R_INT1), maxTokens: optF(R_INT1) }))) }, { verdict: reqF(oneOfRule("probe verdict", PROBE_VERDICTS)), detail: reqF(R_STR) }));
 const checkSessionMcpPanelFailure = seatShapeCheck(armsRule("readSessionMcpPanel failure", "kind", {
     unreadable: DEVICE_UNREADABLE_SPEC,
     transport: DEVICE_TRANSPORT_SPEC,
@@ -1116,6 +1283,114 @@ const checkSessionModsResult = seatCheck((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 checkMcpServersListResult = localConfigListCheck((v) => leafVerdict(checkMcpServerReportView(v)));
+const checkMcpServerProbeResult = seatCheck((v) => leafVerdict(checkMcpServerProbeView(v)));
+const checkMcpServerEditResult = seatCheck((v) => leafVerdict(checkMcpServerEditOutcomeView(v)));
+const SKILL_EFFECTIVE = shapeRule("skill effective", {
+    value: reqF(oneOfRule("skill state", SKILL_OVERRIDE_STATES)),
+    decidedBy: reqF(oneOfRule("skill decider", SKILL_OVERRIDE_DECIDERS)),
+});
+const SKILL_EDITABLE = {
+    label: "skill editable",
+    test: (v, path) => {
+        if (!isPlainRecord(v))
+            return bad("not object", path === "" ? undefined : path);
+        const ok = own(v, "ok");
+        if (ok === true)
+            return shapeVerdict({ ok: reqF(R_TRUE) }, v, path);
+        if (ok === false)
+            return shapeVerdict({ ok: reqF(R_FALSE), lockedBy: reqF(oneOfRule("skill lock source", SKILL_OVERRIDE_LOCK_SOURCES)) }, v, path);
+        return bad("bad value (skill editable)", pathAt(path, "ok"));
+    },
+};
+const SKILL_ENTRY_BASE = {
+    name: reqF(R_NONEMPTY),
+    layer: reqF(oneOfRule("skill layer", SKILLS_VIEW_LAYERS)),
+    effective: reqF(SKILL_EFFECTIVE),
+    editable: reqF(SKILL_EDITABLE),
+};
+const SKILL_ENTRY = armsRule("skill entry", "status", {
+    applied: { ...SKILL_ENTRY_BASE, description: optF(R_NONEMPTY), nameOnly: optF(R_TRUE) },
+    excluded: { ...SKILL_ENTRY_BASE, reason: reqF(oneOfRule("skill excluded reason", SKILLS_VIEW_EXCLUDED_REASONS)) },
+}, { applied: [["description"], ["nameOnly"]] });
+const checkSkillsView = seatShapeCheck(shapeRule("skills view", {
+    entries: reqF(arrayRule(SKILL_ENTRY)),
+    withheldRoots: reqF(shapeRule("withheld roots", { untrusted: reqF(R_INT0), unconfirmed: reqF(R_INT0) })),
+}));
+const checkListSkillsResult = localConfigListCheck(checkSkillsView);
+const checkEditSkillsResult = seatShapeCheck(shapeRule("editSkills result", { receipt: reqF(R_LOCAL_CONFIG_RECEIPT) }));
 const MCP_TOOL_TOGGLE_KEY = shapeRule("toggle key", {
     server: reqF(R_NONEMPTY),
     tool: reqF(R_NONEMPTY),
@@ -1280,7 +1555,75 @@ export function planSetNotificationLevel(type, level, supported) {
         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"]);
+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;
@@ -1293,6 +1636,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 });
@@ -1311,6 +1655,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")
@@ -1763,6 +2109,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 {
@@ -2037,23 +2385,43 @@ 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 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 checkSettledElsewhereSlot = seatCheck((v) => R_SETTLED_ELSEWHERE.test(v, "settledElsewhere"));
+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 (typeof ack !== "object" || ack === null)
+        if (checkToolPermissionAck(ack) !== true)
             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 });
     }
@@ -2061,6 +2429,22 @@ export function readToolPermissionSettledElsewhere(ack) {
         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))
@@ -2213,6 +2597,9 @@ export const LOCAL_SESSIONS_SPEC = {
         listOnboardProviders: { kind: "invoke", check: checkOnboardProvidersResult },
         probeOnboardEntry: { kind: "invoke", check: checkOnboardProbeResult },
         applyOnboardEntry: { kind: "invoke", check: checkOnboardApplyResult },
+        listModelPool: { kind: "invoke", check: checkModelPoolListResult },
+        editModelPool: { kind: "invoke", check: checkModelPoolEditResult },
+        discoverModels: { kind: "invoke", check: checkModelDiscoveryResult },
         readSessionMcpPanel: { kind: "invoke", check: checkSessionMcpPanelResult },
         listMcpToolToggles: { kind: "invoke", check: checkMcpToolTogglesResult },
         setMcpToolToggle: { kind: "invoke", check: checkOkAck },
@@ -2221,8 +2608,16 @@ export const LOCAL_SESSIONS_SPEC = {
         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 },
+        listMcpServers: { kind: "invoke", check: checkMcpServersListResult },
+        probeMcpServerEntry: { kind: "invoke", check: checkMcpServerProbeResult },
+        editMcpServer: { kind: "invoke", check: checkMcpServerEditResult },
+        listSkills: { kind: "invoke", check: checkListSkillsResult },
+        editSkills: { kind: "invoke", check: checkEditSkillsResult },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
         onSeatAction: { kind: "event", check: checkSeatAction },
@@ -2270,6 +2665,9 @@ export const SEAT_METHOD_NAMES = [
     "listOnboardProviders",
     "probeOnboardEntry",
     "applyOnboardEntry",
+    "listModelPool",
+    "editModelPool",
+    "discoverModels",
     "readSessionMcpPanel",
     "listMcpToolToggles",
     "setMcpToolToggle",
@@ -2278,8 +2676,16 @@ export const SEAT_METHOD_NAMES = [
     "setComputerUse",
     "getNotificationLevels",
     "setNotificationLevel",
+    "getQuickEntryShortcut",
+    "setQuickEntryShortcut",
     "claimSeatActions",
     "readSessionMods",
+    "readSessionHooksRoster",
+    "listMcpServers",
+    "probeMcpServerEntry",
+    "editMcpServer",
+    "listSkills",
+    "editSkills",
     "onEvent",
     "onToolPermissionRequest",
     "onSeatAction",
@@ -2524,6 +2930,10 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "aliases",
                 why: "受理面(0.108.0 CC-944;除行名之外引擎还认的模型词),读法归 modelAcceptanceOf(缺席 = 更早的服务端,照旧判;在场而坏形 ⇒ 没找到行的词读 catalog_unreadable);出站门为它拒掉整份目录 = 选单为一份受理数据整个消失。",
             },
+            {
+                key: "unreadableRows",
+                why: "完整性面(0.112.0 CC-1229;回体读口丢掉的行数,`> 0` 才在场),读法归 modelAcceptanceOf 的读不全判(非正数 / 非数一律不算丢行);出站门为它拒掉整份目录 = 选单为一个计数整个消失。",
+            },
         ],
     },
     SendMessageRequest: {
@@ -2601,7 +3011,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     ToolPermissionAck: {
         check: checkToolPermissionAck,
-        validated: ["ok", "settledElsewhere"],
+        validated: ["ok", "settledElsewhere", "unconfirmed"],
         unchecked: [],
     },
     GetTranscriptResult: {
@@ -2631,7 +3041,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions", "notificationLevels", "modsView", "quickEntryShortcut", "hooksRoster", "mcpServers", "mcpServerEdit", "skills", "skillsEdit", "modelPool", "modelPoolEdit"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2699,10 +3109,23 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["SetComputerUseRequest", checkSetComputerUseRequest],
         ["NotificationLevelsState", checkNotificationLevelsState],
         ["SetNotificationLevelResult", checkSetNotificationLevelResult],
+        ["ModelPoolListResult", checkModelPoolListResult],
+        ["ModelPoolEditResult", checkModelPoolEditResult],
+        ["ModelDiscoveryResult", checkModelDiscoveryResult],
+        ["ModelPoolEditRequest", checkModelPoolEditRequest],
+        ["ModelDiscoveryRequest", checkModelDiscoveryRequest],
         ["SeatAction", checkSeatAction],
         ["EngineSwapAnswerOutcome", checkEngineSwapAnswerOutcome],
         ["SelfUpgradeOutcome", checkSelfUpgradeOutcome],
         ["SessionModsResult", checkSessionModsResult],
+        ["QuickEntryShortcutState", checkQuickEntryShortcutState],
+        ["SetQuickEntryShortcutResult", checkSetQuickEntryShortcutResult],
+        ["SessionHooksRosterResult", checkSessionHooksRosterResult],
+        ["McpServersListResult", checkMcpServersListResult],
+        ["McpServerProbeResult", checkMcpServerProbeResult],
+        ["McpServerEditResult", checkMcpServerEditResult],
+        ["ListSkillsResult", checkListSkillsResult],
+        ["EditSkillsResult", checkEditSkillsResult],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2753,6 +3176,7 @@ 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,
@@ -2769,6 +3193,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, true, true, true,
 ];
 void _seatContractPins;