@sema-agent/client-core 0.111.0 → 0.112.1

package/dist/seatContract.js

@@ -4,11 +4,18 @@ import { liveDefaultModelCopy, liveModelRowCopy } from "./model/liveCatalogShape
 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";
@@ -406,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", "quickEntryShortcut", "hooksRoster"]);
+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 });
@@ -490,6 +497,12 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     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)
@@ -939,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) };
@@ -1002,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),
@@ -1013,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,
@@ -1198,6 +1355,42 @@ const checkSessionHooksRosterResult = seatCheck((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),
@@ -2404,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 },
@@ -2417,6 +2613,11 @@ export const LOCAL_SESSIONS_SPEC = {
         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 },
@@ -2464,6 +2665,9 @@ export const SEAT_METHOD_NAMES = [
     "listOnboardProviders",
     "probeOnboardEntry",
     "applyOnboardEntry",
+    "listModelPool",
+    "editModelPool",
+    "discoverModels",
     "readSessionMcpPanel",
     "listMcpToolToggles",
     "setMcpToolToggle",
@@ -2477,6 +2681,11 @@ export const SEAT_METHOD_NAMES = [
     "claimSeatActions",
     "readSessionMods",
     "readSessionHooksRoster",
+    "listMcpServers",
+    "probeMcpServerEntry",
+    "editMcpServer",
+    "listSkills",
+    "editSkills",
     "onEvent",
     "onToolPermissionRequest",
     "onSeatAction",
@@ -2721,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: {
@@ -2828,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", "quickEntryShortcut", "hooksRoster"],
+        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: {
@@ -2896,6 +3109,11 @@ 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],
@@ -2903,6 +3121,11 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["QuickEntryShortcutState", checkQuickEntryShortcutState],
         ["SetQuickEntryShortcutResult", checkSetQuickEntryShortcutResult],
         ["SessionHooksRosterResult", checkSessionHooksRosterResult],
+        ["McpServersListResult", checkMcpServersListResult],
+        ["McpServerProbeResult", checkMcpServerProbeResult],
+        ["McpServerEditResult", checkMcpServerEditResult],
+        ["ListSkillsResult", checkListSkillsResult],
+        ["EditSkillsResult", checkEditSkillsResult],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2953,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,
@@ -2969,6 +3193,8 @@ 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,

package/dist/sessionIdSegment.d.ts

@@ -1,3 +1,4 @@
+export declare function isDotSegment(seg: string): boolean;
 export declare function isSessionIdPathSegment(id: unknown): id is string;
 export type SessionIdRefusalWhy = 'not_string' | 'bad_shape' | 'bad_version' | 'bad_variant';
 export interface SessionIdRefusal {

package/dist/sessionIdSegment.js

@@ -1,5 +1,8 @@
+export function isDotSegment(seg) {
+    return seg === '.' || seg === '..';
+}
 export function isSessionIdPathSegment(id) {
-    if (typeof id !== 'string' || id === '' || id === '.' || id === '..')
+    if (typeof id !== 'string' || id === '' || isDotSegment(id))
         return false;
     try {
         encodeURIComponent(id);

package/dist/sessionMemoryErase.js

@@ -2,6 +2,7 @@ import { isLoopbackWireUrl, resolveWireAuth } from './engineWireSdk.js';
 import { INJECTED_WIRE_SETTLE_MS, connectionLostDetail, noAnswerDetailFrom, noAnswerKindOf, provablyNotSent, settleInjected } from './engineWireFor.js';
 import { memoryEraseReplayPosture, readMemoryEraseReceipt } from './memoryEntriesWire.js';
 import { normalizeWirePrincipal } from './principalWire.js';
+import { MEMORY_CONTROL_PLANE_CORRUPT } from './engineErrorCodes.js';
 import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const PRINCIPAL_HEADER = 'x-agent-principal';
@@ -359,7 +360,7 @@ function bandOfCode(code) {
             return { unconfirmed: 'store_link_outside' };
         case 'memory.scope_home_not_directory':
             return { unconfirmed: 'store_home_not_directory' };
-        case 'internal.memory_control_plane_corrupt':
+        case MEMORY_CONTROL_PLANE_CORRUPT:
             return { unconfirmed: 'control_plane_corrupt' };
         case 'internal.error':
             return { unconfirmed: 'engine_fault' };

package/dist/sha256Bytes.d.ts

@@ -0,0 +1 @@
+export declare function sha256BytesHex(msg: Uint8Array): string;

package/dist/sha256Bytes.js

@@ -0,0 +1,46 @@
+export function sha256BytesHex(msg) {
+    const k = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    const h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+    const len = msg.length;
+    const padded = new Uint8Array(((len + 8) >>> 6) * 64 + 64);
+    padded.set(msg);
+    padded[len] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(len / 0x20000000));
+    view.setUint32(padded.length - 4, (len << 3) >>> 0);
+    const w = new Array(64).fill(0);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < padded.length; off += 64) {
+        for (let t = 0; t < 16; t++)
+            w[t] = view.getUint32(off + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const x = w[t - 15] ?? 0;
+            const y = w[t - 2] ?? 0;
+            const s0 = rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3);
+            const s1 = rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10);
+            w[t] = ((w[t - 16] ?? 0) + s0 + (w[t - 7] ?? 0) + s1) | 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let t = 0; t < 64; t++) {
+            const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + (k[t] ?? 0) + (w[t] ?? 0)) | 0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        const next = [a, b, c, d, e, f, g, hh];
+        for (let i = 0; i < 8; i++)
+            h[i] = ((h[i] ?? 0) + (next[i] ?? 0)) | 0;
+    }
+    return h.map((x) => (x >>> 0).toString(16).padStart(8, '0')).join('');
+}

package/dist/skillOverrideChain.d.ts

@@ -0,0 +1,83 @@
+import type { SettingsDocument } from './host.js';
+export declare const SKILL_OVERRIDE_STATES: readonly ["on", "name-only", "user-invocable-only", "off"];
+export type SkillOverrideState = (typeof SKILL_OVERRIDE_STATES)[number];
+export declare const SKILL_ORIGINS: readonly ["skills", "synced", "commands", "mcp", "plugin", "builtin", "bundled"];
+export type SkillOrigin = (typeof SKILL_ORIGINS)[number];
+export declare const SKILL_OVERRIDE_LAYERS: readonly ["policySettings", "flagSettings", "localSettings", "projectSettings", "userSettings"];
+export type SkillOverrideLayer = (typeof SKILL_OVERRIDE_LAYERS)[number];
+type PlainLayer = 'localSettings' | 'projectSettings' | 'userSettings';
+export declare const SKILL_OVERRIDE_DECIDERS: readonly ["policySettings", "flagSettings", "localSettings", "projectSettings", "userSettings", "session", "default", "plugin", "builtin_clamp", "hidden_behind_plugin"];
+export type SkillOverrideDecider = (typeof SKILL_OVERRIDE_DECIDERS)[number];
+export declare const SKILL_OVERRIDE_LOCK_SOURCES: readonly ["policy", "flag", "plugin", "skill-author", "reserved-name"];
+export type SkillOverrideLockSource = (typeof SKILL_OVERRIDE_LOCK_SOURCES)[number];
+export interface SkillSyncedName {
+    readonly name: string;
+    readonly bare: string;
+}
+export interface SkillOverrideSubject {
+    readonly name: string;
+    readonly origin: SkillOrigin;
+    readonly unqualifiedName?: string;
+    readonly bareNameReserved?: boolean;
+    readonly aliases?: readonly string[];
+    readonly mcpLabels?: readonly string[];
+    readonly reservedLabels?: readonly string[];
+    readonly syncedNames?: readonly SkillSyncedName[];
+    readonly followsSyncedSkillState?: boolean;
+    readonly disableModelInvocation?: boolean;
+    readonly hiddenBehindPlugin?: boolean;
+}
+export interface SkillOverrideLayers {
+    readonly policySettings?: SettingsDocument | null;
+    readonly flagSettings?: SettingsDocument | null;
+    readonly localSettings?: SettingsDocument | null;
+    readonly projectSettings?: SettingsDocument | null;
+    readonly userSettings?: SettingsDocument | null;
+    readonly session?: {
+        readonly [name: string]: string;
+    } | null;
+    readonly disabledSources?: readonly PlainLayer[];
+    readonly bundledSkillsDisabledByEnv?: boolean;
+}
+export interface SkillOverrideEffective {
+    readonly value: SkillOverrideState;
+    readonly decidedBy: SkillOverrideDecider;
+}
+export interface SkillOverrideLock {
+    readonly source: SkillOverrideLockSource;
+    readonly value: SkillOverrideState;
+}
+export interface ShapedSkillSubject {
+    readonly name: string;
+    readonly origin: SkillOrigin;
+    readonly unqualifiedName: string | undefined;
+    readonly bareNameReserved: boolean;
+    readonly aliases: readonly string[];
+    readonly mcpLabels: readonly string[];
+    readonly reservedLabels: readonly string[];
+    readonly syncedNames: readonly SkillSyncedName[];
+    readonly followsSyncedSkillState: boolean;
+    readonly disableModelInvocation: boolean;
+    readonly hiddenBehindPlugin: boolean;
+}
+export declare function shapeSkillSubject(v: SkillOverrideSubject | null | undefined): ShapedSkillSubject | undefined;
+export interface ShapedSkillLayers {
+    readonly docs: {
+        readonly [L in SkillOverrideLayer]: object | undefined;
+    };
+    readonly session: object | undefined;
+    readonly enabled: (layer: SkillOverrideLayer) => boolean;
+    readonly bundledDisabled: boolean;
+}
+export declare function shapeSkillLayers(v: SkillOverrideLayers | null | undefined): ShapedSkillLayers;
+export declare function bareNameOf(s: ShapedSkillSubject): string | undefined;
+export declare function secondaryNamesOf(s: ShapedSkillSubject): string[];
+export declare function effectiveOfShaped(L: ShapedSkillLayers, s: ShapedSkillSubject): SkillOverrideEffective;
+export declare function lockOfShaped(L: ShapedSkillLayers, s: ShapedSkillSubject): SkillOverrideLock | undefined;
+export declare function skillOverrideEffectiveOf(layers: SkillOverrideLayers, skill: SkillOverrideSubject): SkillOverrideEffective | undefined;
+export declare function skillOverrideLockOf(layers: SkillOverrideLayers, skill: SkillOverrideSubject): SkillOverrideLock | undefined;
+export declare function ownValueIn(ov: object | undefined, s: ShapedSkillSubject): SkillOverrideState | undefined;
+export declare function stateAt(ov: object | undefined, key: string | undefined): SkillOverrideState | undefined;
+export declare function lowerTierOf(L: ShapedSkillLayers, s: ShapedSkillSubject, target: 'localSettings' | 'userSettings', skipTargetBare: boolean): SkillOverrideState | undefined;
+export declare function withLayerDoc(L: ShapedSkillLayers, layer: SkillOverrideLayer, doc: SettingsDocument): ShapedSkillLayers;
+export {};