@sellable/install 0.1.597 → 0.1.599

package/container/Dockerfile

@@ -3,12 +3,12 @@ FROM ${HERMES_IMAGE}
 
 USER root
 
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.597
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.599
 ARG MCP_PACKAGE=@sellable/mcp@0.1.860
 ARG INSTALLER_INTEGRITY
 ARG MCP_INTEGRITY=sha512-jRA1KsCV2d4Zcuo5/UmJiP8P0NaoC3ZDvUFRQOc2AMSNDVmUR6gWvtkyAiqb1lukbFWKzfVlz2/4EWzxvb7hkQ==
 
-RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.597" \
+RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.599" \
     && test "${MCP_PACKAGE}" = "@sellable/mcp@0.1.860" \
     && test -n "${INSTALLER_INTEGRITY}" \
     && test "$(npm view "${INSTALLER_PACKAGE}" dist.integrity)" = "${INSTALLER_INTEGRITY}" \
@@ -23,9 +23,9 @@ RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.597" \
     && mkdir -p /opt/sellable-agent/install-root /opt/sellable-agent/mcp-root \
     && npm install --prefix /opt/sellable-agent/install-root --omit=dev --ignore-scripts --no-audit --no-fund "${INSTALLER_PACKAGE}" \
     && npm install --prefix /opt/sellable-agent/mcp-root --omit=dev --ignore-scripts --no-audit --no-fund "${MCP_PACKAGE}" \
-    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.597' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.860') throw new Error('package identity rejected');" \
+    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.599' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.860') throw new Error('package identity rejected');" \
     && node --input-type=module -e "import { buildExternalRuntimeClosure } from '/opt/sellable-agent/install-root/node_modules/@sellable/install/lib/sellable-agent/external-runtime-builder.mjs'; const built = buildExternalRuntimeClosure({ mcpPackageRoot: '/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp', mcpNodeModulesRoot: '/opt/sellable-agent/mcp-root/node_modules', hermesSourceRoot: '/opt/hermes', ownerUid: 0, ownerGid: 0 }); if (!built.closureDigest) throw new Error('runtime closure rejected');" \
-    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.597', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.860', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
+    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.599', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.860', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
     && npm cache clean --force
 
 COPY entrypoint.sh /usr/local/bin/sellable-agent-container-entrypoint

package/container/README.md

@@ -3,13 +3,13 @@
 This image is a dedicated Agent worker/runtime boundary beside an existing Hermes dashboard. It never replaces or reconfigures the dashboard container.
 
 Build from this directory after
-`@sellable/install@0.1.597` is
+`@sellable/install@0.1.599` is
 published:
 
 ```sh
 docker build --platform linux/amd64 \
   --build-arg INSTALLER_INTEGRITY='sha512-…' \
-  --tag sellable-agent-host:0.1.597 .
+  --tag sellable-agent-host:0.1.599 .
 ```
 
 Create a private `bootstrap/` directory owned by root with mode `0700`. It must contain `bootstrap.json`, `provider-auth`, and `slack-app`, each owned by root with mode `0600`. `bootstrap.json` contains only non-secret identities, hashes, package integrities, and the control-plane URL. The other two files contain the provider JSON and global Slack app token whose hashes are pinned by `bootstrap.json`.

package/lib/sellable-agent/fly-admin-image/Dockerfile

@@ -103,6 +103,8 @@ COPY fly-soul-bridge.mjs /usr/local/lib/sellable-agent/fly-soul-bridge.mjs
 COPY fly-soul-bridge-exec.mjs /usr/local/lib/sellable-agent/fly-soul-bridge-exec.mjs
 COPY fly-skills-bridge.mjs /usr/local/lib/sellable-agent/fly-skills-bridge.mjs
 COPY fly-skills-bridge-exec.mjs /usr/local/lib/sellable-agent/fly-skills-bridge-exec.mjs
+COPY fly-capabilities-bridge.mjs /usr/local/lib/sellable-agent/fly-capabilities-bridge.mjs
+COPY fly-capabilities-bridge-exec.mjs /usr/local/lib/sellable-agent/fly-capabilities-bridge-exec.mjs
 COPY soul-artifact-validator.mjs /usr/local/lib/sellable-agent/soul-artifact-validator.mjs
 COPY hermes-memory-dirty.mjs /opt/sellable/bin/hermes-memory-dirty
 COPY hermes-memory-reconcile.sh /opt/sellable/share/hermes-memory-reconcile.sh
@@ -131,13 +133,22 @@ RUN node --input-type=module -e \
       'import("file:///usr/local/lib/sellable-agent/fly-skills-bridge-exec.mjs").then(({ runFlySkillsBridgeExecCli }) => runFlySkillsBridgeExecCli());' \
       > /usr/local/bin/sellable-skills-bridge-exec \
     && chmod 0555 /usr/local/bin/sellable-skills-bridge-exec \
+    && printf '%s\n' \
+      '#!/usr/bin/env node' \
+      'import("file:///usr/local/lib/sellable-agent/fly-capabilities-bridge-exec.mjs").then(({ runFlyCapabilitiesBridgeExecCli }) => runFlyCapabilitiesBridgeExecCli());' \
+      > /usr/local/bin/sellable-capabilities-bridge-exec \
+    && chmod 0555 /usr/local/bin/sellable-capabilities-bridge-exec \
     && sha256sum /usr/local/lib/sellable-agent/fly-soul-bridge.mjs \
       > /usr/local/share/sellable-agent/soul-bridge-source.sha256 \
     && sha256sum /usr/local/lib/sellable-agent/fly-skills-bridge.mjs \
       /usr/local/lib/sellable-agent/fly-skills-bridge-exec.mjs \
       > /usr/local/share/sellable-agent/skills-bridge-source.sha256 \
+    && sha256sum /usr/local/lib/sellable-agent/fly-capabilities-bridge.mjs \
+      /usr/local/lib/sellable-agent/fly-capabilities-bridge-exec.mjs \
+      > /usr/local/share/sellable-agent/capabilities-bridge-source.sha256 \
     && chmod 0444 /usr/local/share/sellable-agent/soul-bridge-source.sha256 \
       /usr/local/share/sellable-agent/skills-bridge-source.sha256 \
+      /usr/local/share/sellable-agent/capabilities-bridge-source.sha256 \
     && chmod 0755 /etc \
     && chmod 0555 \
       /usr/local/lib/sellable-agent/admin-runtime/admin-runtime.mjs \

package/lib/sellable-agent/fly-admin-image/admin-runtime.mjs

@@ -42,6 +42,7 @@ import {
   buildNativeHermesLaunch,
 } from "../admin-artifact/node_modules/@sellable/install/lib/sellable-agent/fly-customer-worker.mjs";
 import sodium from "../admin-artifact/node_modules/libsodium-wrappers/dist/modules-esm/libsodium-wrappers.mjs";
+import { SELLABLE_ALLOWED_TOOLSETS } from "../fly-capabilities-bridge.mjs";
 import {
   claimWithSoulObservation,
   createFlyCustomerControlClient,
@@ -696,6 +697,22 @@ const ADMIN_LIVE_SKILLS_CONFIG_KEYS = Object.freeze([
   "platform_disabled",
 ]);
 
+function adminPreservedSlackToolsets(config) {
+  const platformToolsets = config?.platform_toolsets;
+  if (
+    !platformToolsets ||
+    typeof platformToolsets !== "object" ||
+    Array.isArray(platformToolsets) ||
+    !Object.prototype.hasOwnProperty.call(platformToolsets, "slack")
+  )
+    return null;
+  const slack = Array.isArray(platformToolsets.slack)
+    ? platformToolsets.slack
+    : [];
+  const allowed = new Set(SELLABLE_ALLOWED_TOOLSETS);
+  return [...new Set(slack.filter((name) => allowed.has(name)))].sort();
+}
+
 function adminPreservedSkillsIdentity(profileRoot) {
   if (!existsSync(profileRoot)) return null;
   const entries = [];
@@ -725,6 +742,7 @@ function adminPreservedSkillsIdentity(profileRoot) {
   };
   if (existsSync(skillsRoot)) walk(skillsRoot);
   let disabled = {};
+  let slackToolsets = null;
   if (existsSync(configPath)) {
     const document = parseDocument(readFileSync(configPath, "utf8"));
     if (document.errors.length > 0) {
@@ -738,8 +756,9 @@ function adminPreservedSkillsIdentity(profileRoot) {
         ).map((key) => [key, skills[key]])
       );
     }
+    slackToolsets = adminPreservedSlackToolsets(document.toJS());
   }
-  return sha256(canonicalJson({ disabled, entries }));
+  return sha256(canonicalJson({ disabled, entries, slackToolsets }));
 }
 
 function mergeAdminLiveSkillsConfig(sourceRoot, targetRoot) {
@@ -751,19 +770,28 @@ function mergeAdminLiveSkillsConfig(sourceRoot, targetRoot) {
   if (sourceDocument.errors.length > 0 || targetDocument.errors.length > 0) {
     throw new Error("admin_runtime_live_skills_config_rejected");
   }
-  const sourceSkills = sourceDocument.toJS()?.skills;
-  if (
-    !sourceSkills ||
-    typeof sourceSkills !== "object" ||
-    Array.isArray(sourceSkills)
-  ) {
-    return;
-  }
-  for (const key of ADMIN_LIVE_SKILLS_CONFIG_KEYS) {
-    if (Object.prototype.hasOwnProperty.call(sourceSkills, key)) {
-      targetDocument.setIn(["skills", key], structuredClone(sourceSkills[key]));
+  const sourceConfig = sourceDocument.toJS();
+  const sourceSkills = sourceConfig?.skills;
+  if (sourceSkills !== undefined) {
+    if (
+      !sourceSkills ||
+      typeof sourceSkills !== "object" ||
+      Array.isArray(sourceSkills)
+    ) {
+      throw new Error("admin_runtime_live_skills_config_rejected");
+    }
+    for (const key of ADMIN_LIVE_SKILLS_CONFIG_KEYS) {
+      if (Object.prototype.hasOwnProperty.call(sourceSkills, key)) {
+        targetDocument.setIn(
+          ["skills", key],
+          structuredClone(sourceSkills[key])
+        );
+      }
     }
   }
+  const slackToolsets = adminPreservedSlackToolsets(sourceConfig);
+  if (slackToolsets !== null)
+    targetDocument.setIn(["platform_toolsets", "slack"], slackToolsets);
   atomicPrivateFile(targetPath, targetDocument.toString());
 }
 

package/lib/sellable-agent/fly-capabilities-bridge-exec.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  CAPABILITIES_REQUEST_MAX_BYTES,
+  FlyCapabilitiesBridgeError,
+  executeExternalCapabilitiesBridgeOperation,
+} from "./fly-capabilities-bridge.mjs";
+
+export const FLY_CAPABILITIES_EXEC_ARGUMENT_MAX_BYTES = 96 * 1024;
+export const FLY_CAPABILITIES_EXEC_ARGUMENT_MAX_COUNT = 2;
+
+const BASE64URL_CHUNK = /^[A-Za-z0-9_-]+$/;
+const ENCODED_MAX_BYTES = Math.ceil(CAPABILITIES_REQUEST_MAX_BYTES / 3) * 4;
+
+export function decodeFlyCapabilitiesExecArguments(args) {
+  if (!Array.isArray(args) || args.length === 0)
+    throw new FlyCapabilitiesBridgeError("capabilities_request_rejected");
+  if (args.length > FLY_CAPABILITIES_EXEC_ARGUMENT_MAX_COUNT)
+    throw new FlyCapabilitiesBridgeError("capabilities_request_too_large");
+  let encoded = "";
+  for (const chunk of args) {
+    if (typeof chunk !== "string" || !BASE64URL_CHUNK.test(chunk))
+      throw new FlyCapabilitiesBridgeError("capabilities_request_rejected");
+    if (
+      Buffer.byteLength(chunk, "utf8") >
+      FLY_CAPABILITIES_EXEC_ARGUMENT_MAX_BYTES
+    )
+      throw new FlyCapabilitiesBridgeError("capabilities_request_too_large");
+    encoded += chunk;
+    if (encoded.length > ENCODED_MAX_BYTES)
+      throw new FlyCapabilitiesBridgeError("capabilities_request_too_large");
+  }
+  let bytes;
+  try {
+    bytes = Buffer.from(encoded, "base64url");
+  } catch {
+    throw new FlyCapabilitiesBridgeError("capabilities_request_rejected");
+  }
+  if (
+    bytes.toString("base64url") !== encoded ||
+    bytes.byteLength > CAPABILITIES_REQUEST_MAX_BYTES
+  )
+    throw new FlyCapabilitiesBridgeError("capabilities_request_rejected");
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new FlyCapabilitiesBridgeError("capabilities_request_rejected");
+  }
+}
+
+export async function runFlyCapabilitiesBridgeExecCli() {
+  try {
+    const request = decodeFlyCapabilitiesExecArguments(process.argv.slice(2));
+    const result = executeExternalCapabilitiesBridgeOperation(request);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.ok ? 0 : 2;
+  } catch (error) {
+    process.stdout.write(
+      `${JSON.stringify({
+        ok: false,
+        code:
+          error instanceof FlyCapabilitiesBridgeError
+            ? error.code
+            : "capabilities_bridge_failed",
+      })}\n`
+    );
+    process.exitCode = 2;
+  }
+}
+
+if (
+  resolve(process.argv[1] ?? "") === resolve(fileURLToPath(import.meta.url))
+) {
+  await runFlyCapabilitiesBridgeExecCli();
+}

package/lib/sellable-agent/fly-capabilities-bridge.mjs

@@ -0,0 +1,659 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { isAbsolute, join } from "node:path";
+
+import {
+  SOUL_BRIDGE_DATA_ROOT,
+  discoverLiveHermesGateway,
+  revalidateLiveHermesGateway,
+  soulProfilePaths,
+  withProfileSoulLock,
+} from "./fly-soul-bridge.mjs";
+import { markHermesSnapshotDirty } from "./hermes-memory-snapshot.mjs";
+
+export const CAPABILITIES_BRIDGE_SCHEMA_VERSION =
+  "sellable-agent-capabilities-bridge/v1";
+export const CAPABILITIES_PROOF_SCHEMA_VERSION =
+  "sellable-agent-capabilities-proof/v1";
+export const CAPABILITIES_REQUEST_MAX_BYTES = 16 * 1024;
+
+// Deliberately excludes credential-bearing, external-account, platform-admin,
+// media-generation, and default-off toolsets. These are the already-bundled
+// core capabilities a Sellable Agent operator may narrow or restore for Slack.
+export const SELLABLE_ALLOWED_TOOLSETS = Object.freeze([
+  "clarify",
+  "code_execution",
+  "context_engine",
+  "cronjob",
+  "delegation",
+  "file",
+  "memory",
+  "session_search",
+  "skills",
+  "terminal",
+  "todo",
+]);
+
+const ALLOWED_TOOLSETS = new Set(SELLABLE_ALLOWED_TOOLSETS);
+const PROFILE_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const BOUND_ID = /^[A-Za-z0-9_-]{1,128}$/;
+const TOOLSET_NAME = /^[a-z][a-z0-9_]{0,127}$/;
+const TOOL_NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,255}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+const VERSION = /^[0-9A-Za-z][0-9A-Za-z.+-]{0,127}$/;
+const PYTHON = "/opt/hermes/.venv/bin/python3";
+const EXPECTED_PACKAGES = Object.freeze({
+  sellable: "@sellable/mcp",
+  "sellable-admin": "@sellable/admin-mcp",
+});
+
+/**
+ * @typedef {{
+ *   enumerate: (input: any) => any,
+ *   toggle: (input: any) => any,
+ * }} CapabilitiesNativeAdapter
+ */
+
+/**
+ * @typedef {{
+ *   profileId?: string,
+ *   dataRoot?: string,
+ *   nativeAdapter?: CapabilitiesNativeAdapter | null,
+ *   packageSpecs?: Record<string, string> | null,
+ *   markDirty?: (profileRoot: string) => void,
+ *   lockHeld?: boolean,
+ * }} CapabilitiesBridgeOptions
+ */
+
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const stableJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+
+export class FlyCapabilitiesBridgeError extends Error {
+  constructor(code) {
+    super(code);
+    this.name = "FlyCapabilitiesBridgeError";
+    this.code = code;
+  }
+}
+
+function fail(code) {
+  throw new FlyCapabilitiesBridgeError(code);
+}
+
+function regularFile(path, maxBytes = 2 * 1024 * 1024) {
+  const link = lstatSync(path);
+  if (
+    link.isSymbolicLink() ||
+    !link.isFile() ||
+    link.nlink !== 1 ||
+    link.size > maxBytes
+  ) {
+    fail("capabilities_config_rejected");
+  }
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const opened = fstatSync(fd);
+    if (
+      !opened.isFile() ||
+      opened.dev !== link.dev ||
+      opened.ino !== link.ino ||
+      opened.nlink !== 1 ||
+      opened.size !== link.size
+    ) {
+      fail("capabilities_config_changed");
+    }
+    return readFileSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function assertExactKeys(value, allowed) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    fail("capabilities_request_rejected");
+  if (Object.keys(value).some((key) => !allowed.has(key)))
+    fail("capabilities_request_rejected");
+}
+
+function expectedAliases(kind) {
+  return kind === "ADMIN" ? ["sellable", "sellable-admin"] : ["sellable"];
+}
+
+function assertRequest(request) {
+  const common = ["operation", "expectedRuntimeKind", "expectedWorkspaceId"];
+  const shapes = {
+    list: common,
+    toggle_tool: [...common, "toolsetName", "enabled", "configSha256"],
+    test_mcp: [...common, "serverName"],
+  };
+  const keys = shapes[request?.operation];
+  if (!keys) fail("capabilities_operation_rejected");
+  assertExactKeys(request, new Set(keys));
+  if (!["CUSTOMER", "ADMIN"].includes(request.expectedRuntimeKind))
+    fail("capabilities_runtime_kind_rejected");
+  if (!BOUND_ID.test(request.expectedWorkspaceId ?? ""))
+    fail("capabilities_workspace_rejected");
+  if (request.operation === "toggle_tool") {
+    if (
+      !TOOLSET_NAME.test(request.toolsetName ?? "") ||
+      !ALLOWED_TOOLSETS.has(request.toolsetName)
+    )
+      fail("capabilities_toolset_rejected");
+    if (
+      typeof request.enabled !== "boolean" ||
+      !SHA256.test(request.configSha256 ?? "")
+    )
+      fail("capabilities_cas_rejected");
+  }
+  if (
+    request.operation === "test_mcp" &&
+    !expectedAliases(request.expectedRuntimeKind).includes(request.serverName)
+  )
+    fail("capabilities_mcp_server_rejected");
+  return request;
+}
+
+function parsePackageSpec(spec, expectedName) {
+  if (typeof spec !== "string") fail("capabilities_package_identity_rejected");
+  const delimiter = spec.lastIndexOf("@");
+  const name = spec.slice(0, delimiter);
+  const version = spec.slice(delimiter + 1);
+  if (name !== expectedName || !VERSION.test(version))
+    fail("capabilities_package_identity_rejected");
+  return { packageName: name, version };
+}
+
+function boundedText(value, max) {
+  return typeof value === "string" && Buffer.byteLength(value, "utf8") <= max;
+}
+
+function normalizeNative(native, request, configSha256, packageSpecs) {
+  if (!native || !Array.isArray(native.tools) || !Array.isArray(native.servers))
+    fail("capabilities_native_output_rejected");
+  const tools = native.tools.map((row) => {
+    if (
+      !row ||
+      !ALLOWED_TOOLSETS.has(row.name) ||
+      !boundedText(row.label, 256) ||
+      !boundedText(row.description, 2048) ||
+      row.platform !== "slack" ||
+      typeof row.enabled !== "boolean" ||
+      typeof row.configured !== "boolean" ||
+      !Array.isArray(row.tools) ||
+      row.tools.length > 256 ||
+      row.tools.some((name) => !TOOL_NAME.test(name))
+    )
+      fail("capabilities_tool_inventory_rejected");
+    const names = [...new Set(row.tools)].sort();
+    if (names.length !== row.tools.length)
+      fail("capabilities_tool_inventory_rejected");
+    return Object.freeze({
+      name: row.name,
+      label: row.label,
+      description: row.description,
+      platform: "slack",
+      enabled: row.enabled,
+      available: row.enabled && row.configured,
+      configured: row.configured,
+      policy: "allowed",
+      tools: Object.freeze(names),
+    });
+  });
+  tools.sort((left, right) => left.name.localeCompare(right.name));
+  if (
+    stableJson(tools.map((tool) => tool.name)) !==
+    stableJson([...SELLABLE_ALLOWED_TOOLSETS].sort())
+  )
+    fail("capabilities_tool_inventory_rejected");
+
+  const aliases = expectedAliases(request.expectedRuntimeKind);
+  const mcpServers = native.servers.map((row) => {
+    if (
+      !row ||
+      !aliases.includes(row.name) ||
+      row.enabled !== true ||
+      row.transport !== "stdio" ||
+      typeof row.workspaceLocked !== "boolean" ||
+      typeof row.requiresWorkspaceLock !== "boolean" ||
+      !["healthy", "unhealthy", "unknown"].includes(row.health) ||
+      !Array.isArray(row.tools) ||
+      row.tools.length > 1024 ||
+      row.tools.some((name) => !TOOL_NAME.test(name)) ||
+      !Number.isSafeInteger(row.prompts) ||
+      row.prompts < 0 ||
+      !Number.isSafeInteger(row.resources) ||
+      row.resources < 0 ||
+      ![null, "probe_failed", "not_tested"].includes(row.errorCode)
+    )
+      fail("capabilities_mcp_inventory_rejected");
+    if (
+      row.name === "sellable" &&
+      (!row.workspaceLocked || !row.requiresWorkspaceLock)
+    )
+      fail("capabilities_workspace_lock_rejected");
+    const names = [...new Set(row.tools)].sort();
+    if (names.length !== row.tools.length)
+      fail("capabilities_mcp_inventory_rejected");
+    return Object.freeze({
+      name: row.name,
+      label: row.name === "sellable" ? "Sellable" : "Sellable Admin",
+      ...parsePackageSpec(packageSpecs[row.name], EXPECTED_PACKAGES[row.name]),
+      enabled: true,
+      managed: true,
+      readOnly: true,
+      transport: "stdio",
+      workspaceLocked: row.workspaceLocked,
+      requiresWorkspaceLock: row.requiresWorkspaceLock,
+      health: row.health,
+      tools: Object.freeze(names),
+      prompts: row.prompts,
+      resources: row.resources,
+      errorCode: row.errorCode,
+    });
+  });
+  mcpServers.sort((left, right) => left.name.localeCompare(right.name));
+  if (
+    stableJson(mcpServers.map((server) => server.name)) !== stableJson(aliases)
+  )
+    fail("capabilities_mcp_inventory_rejected");
+  const inventory = Object.freeze({
+    complete: true,
+    configSha256,
+    tools: Object.freeze(tools),
+    mcpServers: Object.freeze(mcpServers),
+  });
+  return Object.freeze({
+    ...inventory,
+    inventorySha256: sha256(stableJson(inventory)),
+  });
+}
+
+const NATIVE_SCRIPT = String.raw`
+import json, sys
+request = json.loads(sys.stdin.read())
+from hermes_cli.config import load_config
+from hermes_cli.mcp_config import _get_mcp_servers, _probe_single_server
+from hermes_cli.tools_config import CONFIGURABLE_TOOLSETS, _get_platform_tools, _save_platform_tools, _toolset_has_keys
+from toolsets import resolve_toolset
+
+def enumerate_capabilities():
+    allowed = request["allowedToolsets"]
+    config = load_config()
+    catalog = {name: (label, description) for name, label, description in CONFIGURABLE_TOOLSETS}
+    enabled = _get_platform_tools(config, "slack", include_default_mcp_servers=False)
+    tool_rows = []
+    for name in allowed:
+        if name not in catalog:
+            raise RuntimeError("missing_policy_toolset")
+        label, description = catalog[name]
+        label_parts = str(label).strip().split(None, 1)
+        if len(label_parts) == 2 and not any(ch.isascii() and ch.isalnum() for ch in label_parts[0]):
+            label = label_parts[1]
+        tool_rows.append({
+            "name": name,
+            "label": str(label),
+            "description": str(description),
+            "platform": "slack",
+            "enabled": name in enabled,
+            "configured": bool(_toolset_has_keys(name, config)),
+            "tools": sorted(set(resolve_toolset(name, include_registry=False))),
+        })
+
+    servers = _get_mcp_servers(config)
+    expected_aliases = request["expectedAliases"]
+    if sorted(servers.keys()) != sorted(expected_aliases):
+        raise RuntimeError("managed_server_inventory")
+    server_rows = []
+    for name in expected_aliases:
+        server = servers[name]
+        env = server.get("env") if isinstance(server.get("env"), dict) else {}
+        details = {}
+        try:
+            found = _probe_single_server(name, server, connect_timeout=12, details=details)
+            health = "healthy"
+            tools = sorted(set(str(tool_name) for tool_name, _description in found))
+            prompts = int(details.get("prompts", 0) or 0)
+            resources = int(details.get("resources", 0) or 0)
+            error_code = None
+        except BaseException:
+            health, tools, prompts, resources, error_code = "unhealthy", [], 0, 0, "probe_failed"
+        server_rows.append({
+            "name": name,
+            "enabled": server.get("enabled", True) is not False,
+            "transport": "http" if server.get("url") else "stdio" if server.get("command") else "unknown",
+            "workspaceLocked": env.get("SELLABLE_LOCK_WORKSPACE_ID") == request["expectedWorkspaceId"],
+            "requiresWorkspaceLock": str(env.get("SELLABLE_REQUIRE_WORKSPACE_LOCK", "")) == "1",
+            "health": health,
+            "tools": tools,
+            "prompts": prompts,
+            "resources": resources,
+            "errorCode": error_code,
+        })
+    return {"tools": tool_rows, "servers": server_rows}
+
+if request["operation"] == "enumerate":
+    output = enumerate_capabilities()
+elif request["operation"] == "toggle":
+    config = load_config()
+    enabled = set(_get_platform_tools(config, "slack", include_default_mcp_servers=False))
+    if request["enabled"]: enabled.add(request["name"])
+    else: enabled.discard(request["name"])
+    _save_platform_tools(config, "slack", enabled)
+    output = {"ok": True}
+else:
+    raise RuntimeError("operation")
+sys.stdout.write(json.dumps(output, separators=(",", ":")))
+`;
+
+function runNative(payload, paths, { python = PYTHON } = {}) {
+  const child = spawnSync(python, ["-c", NATIVE_SCRIPT], {
+    input: JSON.stringify(payload),
+    encoding: "utf8",
+    timeout: 30_000,
+    maxBuffer: 4 * 1024 * 1024,
+    env: {
+      HOME: paths.dataRoot,
+      HERMES_HOME: paths.profileRoot,
+      HERMES_PROFILE: paths.profileId,
+      SELLABLE_HERMES_PROFILE_ID: paths.profileId,
+      SELLABLE_AGENT_RUNTIME: "1",
+      PYTHONDONTWRITEBYTECODE: "1",
+      PATH: "/opt/hermes/.venv/bin:/usr/local/bin:/usr/bin:/bin",
+    },
+  });
+  if (child.status !== 0 || child.signal || child.error)
+    fail("capabilities_native_call_failed");
+  try {
+    return JSON.parse(child.stdout);
+  } catch {
+    fail("capabilities_native_output_rejected");
+  }
+}
+
+function defaultAdapter(paths) {
+  return {
+    enumerate: ({
+      expectedAliases: aliases,
+      expectedWorkspaceId,
+      probeServerName,
+    }) =>
+      runNative(
+        {
+          operation: "enumerate",
+          allowedToolsets: SELLABLE_ALLOWED_TOOLSETS,
+          expectedAliases: aliases,
+          expectedWorkspaceId,
+          ...(probeServerName ? { probeServerName } : {}),
+        },
+        paths
+      ),
+    toggle: ({ name, enabled }) =>
+      runNative({ operation: "toggle", name, enabled }, paths),
+  };
+}
+
+function runtimePackageSpecs(kind, provided) {
+  if (provided) return provided;
+  return kind === "ADMIN"
+    ? {
+        sellable: process.env.SELLABLE_AGENT_PRODUCT_MCP_PACKAGE,
+        "sellable-admin": process.env.SELLABLE_AGENT_ADMIN_MCP_PACKAGE,
+      }
+    : { sellable: process.env.SELLABLE_AGENT_MCP_PACKAGE };
+}
+
+function atomicProof(paths, inventory) {
+  const root = join(paths.profileRoot, ".sellable-agent");
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  const path = join(root, "capabilities-proof.json");
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(
+    temporary,
+    `${JSON.stringify({
+      schemaVersion: CAPABILITIES_PROOF_SCHEMA_VERSION,
+      inventorySha256: inventory.inventorySha256,
+      configSha256: inventory.configSha256,
+    })}\n`,
+    { mode: 0o600 }
+  );
+  renameSync(temporary, path);
+}
+
+function readInventory(request, paths, adapter, packageSpecs) {
+  const configPath = join(paths.profileRoot, "config.yaml");
+  const configSha256 = sha256(regularFile(configPath));
+  const aliases = expectedAliases(request.expectedRuntimeKind);
+  const native = adapter.enumerate({
+    expectedAliases: aliases,
+    expectedWorkspaceId: request.expectedWorkspaceId,
+    ...(request.operation === "test_mcp"
+      ? { probeServerName: request.serverName }
+      : {}),
+  });
+  if (sha256(regularFile(configPath)) !== configSha256)
+    fail("capabilities_config_changed");
+  return normalizeNative(native, request, configSha256, packageSpecs);
+}
+
+function executeLocked(request, paths, adapter, options) {
+  const packageSpecs = runtimePackageSpecs(
+    request.expectedRuntimeKind,
+    options.packageSpecs
+  );
+  const before = readInventory(request, paths, adapter, packageSpecs);
+  if (request.operation === "list" || request.operation === "test_mcp") {
+    atomicProof(paths, before);
+    return {
+      ok: true,
+      schemaVersion: CAPABILITIES_BRIDGE_SCHEMA_VERSION,
+      status: "proven",
+      operation: request.operation,
+      ...(request.operation === "test_mcp"
+        ? { testedServer: request.serverName }
+        : {}),
+      ...before,
+    };
+  }
+  if (request.configSha256 !== before.configSha256) {
+    return {
+      ok: false,
+      code: "capabilities_config_conflict",
+      configSha256: before.configSha256,
+      inventorySha256: before.inventorySha256,
+    };
+  }
+  const detail = before.tools.find((tool) => tool.name === request.toolsetName);
+  if (!detail) fail("capabilities_toolset_rejected");
+  if (detail.enabled === request.enabled) {
+    atomicProof(paths, before);
+    return {
+      ok: true,
+      schemaVersion: CAPABILITIES_BRIDGE_SCHEMA_VERSION,
+      status: "noop",
+      operation: "toggle_tool",
+      ...before,
+      detail,
+    };
+  }
+  const configPath = join(paths.profileRoot, "config.yaml");
+  const configBackup = regularFile(configPath);
+  const proofPath = join(
+    paths.profileRoot,
+    ".sellable-agent",
+    "capabilities-proof.json"
+  );
+  const proofBackup = existsSync(proofPath)
+    ? regularFile(proofPath, 4096)
+    : null;
+  const rollback = () => {
+    writeFileSync(configPath, configBackup, { mode: 0o600 });
+    if (proofBackup) writeFileSync(proofPath, proofBackup, { mode: 0o600 });
+    else rmSync(proofPath, { force: true });
+  };
+  try {
+    const result = adapter.toggle({
+      name: request.toolsetName,
+      enabled: request.enabled,
+      platform: "slack",
+    });
+    if (result?.ok !== true) fail("capabilities_native_refused");
+    const after = readInventory(request, paths, adapter, packageSpecs);
+    const afterDetail = after.tools.find(
+      (tool) => tool.name === request.toolsetName
+    );
+    if (
+      !afterDetail ||
+      afterDetail.enabled !== request.enabled ||
+      after.configSha256 === before.configSha256 ||
+      stableJson(after.mcpServers.map((server) => server.name)) !==
+        stableJson(before.mcpServers.map((server) => server.name))
+    )
+      fail("capabilities_readback_failed");
+    atomicProof(paths, after);
+    options.markDirty(paths.profileRoot);
+    return {
+      ok: true,
+      schemaVersion: CAPABILITIES_BRIDGE_SCHEMA_VERSION,
+      status: "applied",
+      operation: "toggle_tool",
+      effectId: randomUUID(),
+      ...after,
+      detail: afterDetail,
+    };
+  } catch (error) {
+    rollback();
+    try {
+      const restored = readInventory(request, paths, adapter, packageSpecs);
+      if (restored.configSha256 !== before.configSha256)
+        return { ok: false, code: "capabilities_rollback_unproven" };
+    } catch {
+      return { ok: false, code: "capabilities_rollback_unproven" };
+    }
+    return {
+      ok: false,
+      code: "capabilities_apply_failed_rolled_back",
+      reason:
+        error instanceof FlyCapabilitiesBridgeError
+          ? error.code
+          : "capabilities_bridge_failed",
+    };
+  }
+}
+
+/**
+ * @param {any} request
+ * @param {CapabilitiesBridgeOptions} [options]
+ */
+export function executeCapabilitiesBridgeOperation(
+  request,
+  {
+    profileId = process.env.SELLABLE_HERMES_PROFILE_ID,
+    dataRoot = SOUL_BRIDGE_DATA_ROOT,
+    nativeAdapter = null,
+    packageSpecs = null,
+    markDirty = markHermesSnapshotDirty,
+    lockHeld = false,
+  } = {}
+) {
+  assertRequest(request);
+  if (typeof profileId !== "string" || !PROFILE_ID.test(profileId))
+    fail("capabilities_profile_id_rejected");
+  const paths = soulProfilePaths(profileId, { dataRoot });
+  const adapter = nativeAdapter ?? defaultAdapter(paths);
+  if (
+    !adapter ||
+    typeof adapter.enumerate !== "function" ||
+    typeof adapter.toggle !== "function"
+  )
+    fail("capabilities_native_adapter_rejected");
+  if (typeof markDirty !== "function")
+    fail("capabilities_dirty_marker_rejected");
+  const run = () =>
+    executeLocked(request, paths, adapter, { packageSpecs, markDirty });
+  return lockHeld ? run() : withProfileSoulLock(profileId, run, { dataRoot });
+}
+
+export function executeExternalCapabilitiesBridgeOperation(
+  request,
+  {
+    procRoot = "/proc",
+    dataRoot = SOUL_BRIDGE_DATA_ROOT,
+    nativeAdapter = null,
+    packageSpecs = null,
+    markDirty = markHermesSnapshotDirty,
+    callerProfileId = process.env.SELLABLE_HERMES_PROFILE_ID,
+  } = {}
+) {
+  const gateway = discoverLiveHermesGateway({ procRoot, dataRoot });
+  if (callerProfileId && callerProfileId !== gateway.profileId)
+    fail("capabilities_gateway_caller_profile_mismatch");
+  revalidateLiveHermesGateway(gateway, { procRoot, dataRoot });
+  const result = executeCapabilitiesBridgeOperation(request, {
+    profileId: gateway.profileId,
+    dataRoot,
+    nativeAdapter,
+    packageSpecs,
+    markDirty,
+  });
+  revalidateLiveHermesGateway(gateway, { procRoot, dataRoot });
+  return Object.freeze({
+    ...result,
+    profileId: gateway.profileId,
+    gatewayPid: gateway.pid,
+    gatewayStartTicks: gateway.startTicks,
+  });
+}
+
+export function readCapabilitiesProofObservation(profileRoot) {
+  try {
+    if (!isAbsolute(profileRoot)) return null;
+    const value = JSON.parse(
+      regularFile(
+        join(
+          realpathSync(profileRoot),
+          ".sellable-agent",
+          "capabilities-proof.json"
+        ),
+        4096
+      ).toString("utf8")
+    );
+    if (
+      value.schemaVersion !== CAPABILITIES_PROOF_SCHEMA_VERSION ||
+      !SHA256.test(value.inventorySha256 ?? "") ||
+      !SHA256.test(value.configSha256 ?? "") ||
+      Object.keys(value).length !== 3
+    )
+      return null;
+    return Object.freeze({
+      inventorySha256: value.inventorySha256,
+      configSha256: value.configSha256,
+    });
+  } catch {
+    return null;
+  }
+}

package/lib/sellable-agent/fly-customer-image/Dockerfile

@@ -6,7 +6,7 @@ USER root
 
 ARG MCP_PACKAGE=@sellable/mcp@0.1.860
 ARG MCP_INTEGRITY=sha512-jRA1KsCV2d4Zcuo5/UmJiP8P0NaoC3ZDvUFRQOc2AMSNDVmUR6gWvtkyAiqb1lukbFWKzfVlz2/4EWzxvb7hkQ==
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.597
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.599
 ARG ADMIN_MCP_PACKAGE=@sellable/admin-mcp@0.1.186-wip.phase158.20260802034727
 ARG ADMIN_MCP_INTEGRITY=sha512-qYNew5wd2IfgVcp1UYOG9QvpF/8Mx19YJ5HQtMKzvSfUf3evePjtaKsoXLf2C/GUJ5QlLlHJo84VWOI3V01+9A==
 ARG TUS_JS_CLIENT_VERSION=4.3.1
@@ -69,7 +69,7 @@ RUN --mount=type=secret,id=mcp_trust_root,required=true \
              /etc/cont-init.d/02-reconcile-profiles \
     && npm cache clean --force
 
-COPY mcp-context-proxy.mjs mcp-runtime-binding.mjs fly-customer-model.mjs fly-customer-worker.mjs profile-materializer.mjs hermes-bridge.mjs hermes-memory-snapshot.mjs fly-runtime-identity.mjs fly-soul-bridge.mjs fly-soul-bridge-exec.mjs fly-skills-bridge.mjs fly-skills-bridge-exec.mjs soul-artifact-validator.mjs model-auth-reconciler.mjs model-auth-canary-reseed.mjs model-health-reporter.mjs \
+COPY mcp-context-proxy.mjs mcp-runtime-binding.mjs fly-customer-model.mjs fly-customer-worker.mjs profile-materializer.mjs hermes-bridge.mjs hermes-memory-snapshot.mjs fly-runtime-identity.mjs fly-soul-bridge.mjs fly-soul-bridge-exec.mjs fly-skills-bridge.mjs fly-skills-bridge-exec.mjs fly-capabilities-bridge.mjs fly-capabilities-bridge-exec.mjs soul-artifact-validator.mjs model-auth-reconciler.mjs model-auth-canary-reseed.mjs model-health-reporter.mjs \
   /usr/local/lib/sellable-agent/
 COPY hermes-memory-dirty.mjs /opt/sellable/bin/hermes-memory-dirty
 COPY hermes-memory-reconcile.sh /opt/sellable/share/hermes-memory-reconcile.sh
@@ -101,13 +101,22 @@ RUN node --input-type=module -e \
       'import("file:///usr/local/lib/sellable-agent/fly-skills-bridge-exec.mjs").then(({ runFlySkillsBridgeExecCli }) => runFlySkillsBridgeExecCli());' \
       > /usr/local/bin/sellable-skills-bridge-exec \
     && chmod 0555 /usr/local/bin/sellable-skills-bridge-exec \
+    && printf '%s\n' \
+      '#!/usr/bin/env node' \
+      'import("file:///usr/local/lib/sellable-agent/fly-capabilities-bridge-exec.mjs").then(({ runFlyCapabilitiesBridgeExecCli }) => runFlyCapabilitiesBridgeExecCli());' \
+      > /usr/local/bin/sellable-capabilities-bridge-exec \
+    && chmod 0555 /usr/local/bin/sellable-capabilities-bridge-exec \
     && sha256sum /usr/local/lib/sellable-agent/fly-soul-bridge.mjs \
       > /usr/local/share/sellable-agent/soul-bridge-source.sha256 \
     && sha256sum /usr/local/lib/sellable-agent/fly-skills-bridge.mjs \
       /usr/local/lib/sellable-agent/fly-skills-bridge-exec.mjs \
       > /usr/local/share/sellable-agent/skills-bridge-source.sha256 \
+    && sha256sum /usr/local/lib/sellable-agent/fly-capabilities-bridge.mjs \
+      /usr/local/lib/sellable-agent/fly-capabilities-bridge-exec.mjs \
+      > /usr/local/share/sellable-agent/capabilities-bridge-source.sha256 \
     && chmod 0444 /usr/local/share/sellable-agent/soul-bridge-source.sha256 \
       /usr/local/share/sellable-agent/skills-bridge-source.sha256 \
+      /usr/local/share/sellable-agent/capabilities-bridge-source.sha256 \
     && chmod 0755 /etc \
     && chmod 0555 /usr/local/lib/sellable-agent/*.mjs \
     && chmod 0555 /opt/sellable/bin/hermes-memory-dirty /opt/sellable/bin/hermes-endpoint-cron \

package/lib/sellable-agent/fly-customer-image/customer-runtime.mjs

@@ -95,7 +95,7 @@ const RUNTIME_GENERATION = Number(
 const BOOT_SESSION_ID = randomUUID();
 const HERMES_VERSION = process.env.SELLABLE_AGENT_HERMES_VERSION ?? "0.20.0";
 const INSTALLER_PACKAGE =
-  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.597";
+  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.599";
 const MCP_PACKAGE =
   process.env.SELLABLE_AGENT_MCP_PACKAGE ?? "@sellable/mcp@0.1.860";
 
@@ -172,11 +172,11 @@ export function assertCustomerRuntimeInstallerPackage({
   ) {
     throw new Error("customer_runtime_installer_package_invalid");
   }
-  if (expected !== actual) {
-    throw new Error(
-      `customer_runtime_installer_package_mismatch:expected=${expected}:actual=${actual}`
-    );
-  }
+  // Runtime releases are selected by immutable image digest. The backend and
+  // image are promoted in adjacent steps, so the signed claim can briefly name
+  // the next package while this Machine still runs the previously active
+  // digest (or vice versa). The image must materialize its own pinned package;
+  // rejecting the version skew wedges otherwise compatible Stop/Start actions.
   return actual;
 }
 
@@ -282,7 +282,9 @@ function compileDesired(claim, trustRootPem) {
   ) {
     throw new Error("customer_claim_contract_rejected");
   }
-  assertCustomerRuntimeInstallerPackage({ expected: installerPackage });
+  const imageInstallerPackage = assertCustomerRuntimeInstallerPackage({
+    expected: installerPackage,
+  });
   const modelEnvelope = claim.secretEnvelopes.modelCodex;
   if (
     model.provider !== "codex" ||
@@ -375,7 +377,7 @@ function compileDesired(claim, trustRootPem) {
       accessPolicyHash,
       runtimeDesiredHash,
       hermesVersion: HERMES_VERSION,
-      installerPackage,
+      installerPackage: imageInstallerPackage,
       mcpPackage: MCP_PACKAGE,
       policyHash: service.policyHash,
       soul: exactArtifact(claim, "SOUL"),

package/lib/sellable-agent/host-bootstrap.mjs

@@ -38,7 +38,7 @@ import { installAgentHostServices } from "./service-installer.mjs";
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 const VERSION = "sellable-agent-host-bootstrap/v1";
 const RECEIPT_VERSION = "sellable-agent-host-registration/v1";
-const INSTALLER_PACKAGE = "@sellable/install@0.1.597";
+const INSTALLER_PACKAGE = "@sellable/install@0.1.599";
 const MCP_PACKAGE = "@sellable/mcp@0.1.860";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;

package/lib/sellable-agent/host-worker.mjs

@@ -1546,7 +1546,7 @@ export function compileClaimToProfileDesired(activeClaim, config) {
       ]) ||
       pinned.hermesCli !== "hermes" ||
       pinned.hermesVersion !== "0.18.0" ||
-      pinned.installerPackage !== "@sellable/install@0.1.597" ||
+      pinned.installerPackage !== "@sellable/install@0.1.599" ||
       pinned.mcpPackage !== "@sellable/mcp@0.1.860" ||
       !Array.isArray(policy.toolInclude) ||
       policy.toolInclude.length === 0 ||

package/lib/sellable-agent/profile-materializer.mjs

@@ -25,6 +25,7 @@ import {
   resolve,
 } from "node:path";
 import { parseDocument } from "yaml";
+import { SELLABLE_ALLOWED_TOOLSETS } from "./fly-capabilities-bridge.mjs";
 import {
   FLY_CUSTOMER_MODEL_ID,
   FLY_CUSTOMER_MODEL_PROVIDER,
@@ -277,7 +278,7 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !== "@sellable/install@0.1.597" ||
+    desired.installerPackage !== "@sellable/install@0.1.599" ||
     desired.mcpPackage !== "@sellable/mcp@0.1.860" ||
     !Array.isArray(desired.toolInclude) ||
     desired.toolInclude.length === 0 ||
@@ -487,7 +488,7 @@ const LIVE_SKILLS_CONFIG_KEYS = Object.freeze([
   "platform_disabled",
 ]);
 
-function profileConfigWithoutLiveSkills(value) {
+function profileConfigWithoutLiveState(value) {
   const normalized = structuredClone(value);
   if (
     normalized?.skills &&
@@ -497,6 +498,15 @@ function profileConfigWithoutLiveSkills(value) {
     for (const key of LIVE_SKILLS_CONFIG_KEYS) delete normalized.skills[key];
     if (Object.keys(normalized.skills).length === 0) delete normalized.skills;
   }
+  if (
+    normalized?.platform_toolsets &&
+    typeof normalized.platform_toolsets === "object" &&
+    !Array.isArray(normalized.platform_toolsets)
+  ) {
+    delete normalized.platform_toolsets.slack;
+    if (Object.keys(normalized.platform_toolsets).length === 0)
+      delete normalized.platform_toolsets;
+  }
   return normalized;
 }
 
@@ -517,12 +527,28 @@ function readProfileConfig(pathValue) {
 function normalizedProfileConfigBytes(pathValue) {
   const value = readProfileConfig(pathValue);
   return Buffer.from(
-    `${JSON.stringify(profileConfigWithoutLiveSkills(value), null, 2)}\n`,
+    `${JSON.stringify(profileConfigWithoutLiveState(value), null, 2)}\n`,
     "utf8"
   );
 }
 
-function mergeLiveSkillsConfig(sourceRoot, targetRoot) {
+function preservedSlackToolsets(config) {
+  const platformToolsets = config?.platform_toolsets;
+  if (
+    !platformToolsets ||
+    typeof platformToolsets !== "object" ||
+    Array.isArray(platformToolsets) ||
+    !Object.prototype.hasOwnProperty.call(platformToolsets, "slack")
+  )
+    return null;
+  const slack = Array.isArray(platformToolsets.slack)
+    ? platformToolsets.slack
+    : [];
+  const allowed = new Set(SELLABLE_ALLOWED_TOOLSETS);
+  return [...new Set(slack.filter((name) => allowed.has(name)))].sort();
+}
+
+function mergeLiveMutableConfig(sourceRoot, targetRoot) {
   const sourcePath = join(sourceRoot, "config.yaml");
   const targetPath = join(targetRoot, "config.yaml");
   if (!existsSync(sourcePath) || !existsSync(targetPath)) return;
@@ -532,27 +558,43 @@ function mergeLiveSkillsConfig(sourceRoot, targetRoot) {
   const source = readProfileConfig(sourcePath);
   const target = readProfileConfig(targetPath);
   const sourceSkills = source?.skills;
+  let changed = false;
   if (
-    !sourceSkills ||
-    typeof sourceSkills !== "object" ||
-    Array.isArray(sourceSkills)
-  ) {
-    return;
+    sourceSkills &&
+    (typeof sourceSkills !== "object" || Array.isArray(sourceSkills))
+  )
+    throw new Error("live skills config rejected");
+  if (sourceSkills) {
+    const preserved = Object.fromEntries(
+      LIVE_SKILLS_CONFIG_KEYS.filter((key) =>
+        Object.prototype.hasOwnProperty.call(sourceSkills, key)
+      ).map((key) => [key, structuredClone(sourceSkills[key])])
+    );
+    if (Object.keys(preserved).length > 0) {
+      target.skills = {
+        ...(target.skills &&
+        typeof target.skills === "object" &&
+        !Array.isArray(target.skills)
+          ? target.skills
+          : {}),
+        ...preserved,
+      };
+      changed = true;
+    }
   }
-  const preserved = Object.fromEntries(
-    LIVE_SKILLS_CONFIG_KEYS.filter((key) =>
-      Object.prototype.hasOwnProperty.call(sourceSkills, key)
-    ).map((key) => [key, structuredClone(sourceSkills[key])])
-  );
-  if (Object.keys(preserved).length === 0) return;
-  target.skills = {
-    ...(target.skills &&
-    typeof target.skills === "object" &&
-    !Array.isArray(target.skills)
-      ? target.skills
-      : {}),
-    ...preserved,
-  };
+  const slackToolsets = preservedSlackToolsets(source);
+  if (slackToolsets !== null) {
+    target.platform_toolsets = {
+      ...(target.platform_toolsets &&
+      typeof target.platform_toolsets === "object" &&
+      !Array.isArray(target.platform_toolsets)
+        ? target.platform_toolsets
+        : {}),
+      slack: slackToolsets,
+    };
+    changed = true;
+  }
+  if (!changed) return;
   atomicWrite(
     targetPath,
     `${JSON.stringify(target, null, 2)}\n`,
@@ -560,15 +602,15 @@ function mergeLiveSkillsConfig(sourceRoot, targetRoot) {
   );
 }
 
-function mergeLiveSkillsState(sourceRoot, targetRoot) {
+function mergeLiveMutableState(sourceRoot, targetRoot) {
   if (!existsSync(sourceRoot)) return;
   const sourceSkills = join(sourceRoot, "skills");
   const targetSkills = join(targetRoot, "skills");
   if (existsSync(sourceSkills)) mergeHermesState(sourceSkills, targetSkills);
-  mergeLiveSkillsConfig(sourceRoot, targetRoot);
+  mergeLiveMutableConfig(sourceRoot, targetRoot);
 }
 
-function preservedSkillsConfigIdentity(profileRoot) {
+function preservedLiveStateIdentity(profileRoot) {
   if (!existsSync(profileRoot)) return null;
   const entries = [];
   const skillsRoot = join(profileRoot, "skills");
@@ -592,6 +634,7 @@ function preservedSkillsConfigIdentity(profileRoot) {
   if (existsSync(skillsRoot)) walk(skillsRoot);
   const configPath = join(profileRoot, "config.yaml");
   let disabled = {};
+  let slackToolsets = null;
   if (existsSync(configPath)) {
     const config = readProfileConfig(configPath);
     const skills = config?.skills;
@@ -602,8 +645,9 @@ function preservedSkillsConfigIdentity(profileRoot) {
         ).map((key) => [key, skills[key]])
       );
     }
+    slackToolsets = preservedSlackToolsets(config);
   }
-  return sha256(stableJson({ disabled, entries }));
+  return sha256(stableJson({ disabled, entries, slackToolsets }));
 }
 
 function mcpFor(desired, profileId) {
@@ -893,7 +937,7 @@ export function validateAgentProfileBundle({ profileRoot, desired }) {
       readFileSync(join(profileRoot, "sellable", "mcp.json"), "utf8")
     );
     if (
-      stableJson(profileConfigWithoutLiveSkills(config)) !==
+      stableJson(profileConfigWithoutLiveState(config)) !==
       stableJson(configFor(desired, manifest.profileId))
     ) {
       return { ok: false, code: "config_drift" };
@@ -1896,14 +1940,14 @@ async function materializeAgentProfileLocked(input = {}) {
       revisionId: desired.revisionId,
       fence: desired.fence,
     });
-    const liveSkillsIdentity = preservedSkillsConfigIdentity(profileRoot);
+    const liveStateIdentity = preservedLiveStateIdentity(profileRoot);
     renderStagedProfile(stagingRoot, desired);
-    mergeLiveSkillsState(profileRoot, stagingRoot);
+    mergeLiveMutableState(profileRoot, stagingRoot);
     if (
-      liveSkillsIdentity !== null &&
-      preservedSkillsConfigIdentity(stagingRoot) !== liveSkillsIdentity
+      liveStateIdentity !== null &&
+      preservedLiveStateIdentity(stagingRoot) !== liveStateIdentity
     ) {
-      throw new Error("live skills identity changed during staging");
+      throw new Error("live mutable state identity changed during staging");
     }
     const staged = validateAgentProfileBundle({
       profileRoot: stagingRoot,
@@ -2721,7 +2765,7 @@ export function materializeNativeSlackCustomerProfile({
         };
       }
       let soulBytes = Buffer.from(desired.soul, "utf8");
-      const liveSkillsIdentity = preservedSkillsConfigIdentity(activeRoot);
+      const liveStateIdentity = preservedLiveStateIdentity(activeRoot);
       if (existsSync(activeRoot)) {
         const soulPath = join(activeRoot, "SOUL.md");
         if (existsSync(soulPath)) {
@@ -2739,12 +2783,12 @@ export function materializeNativeSlackCustomerProfile({
       );
       mergeHermesState(activeRoot, stagingRoot);
       repointInternalCronProfileReferences(desired, stagingRoot);
-      mergeLiveSkillsConfig(activeRoot, stagingRoot);
+      mergeLiveMutableConfig(activeRoot, stagingRoot);
       if (
-        liveSkillsIdentity !== null &&
-        preservedSkillsConfigIdentity(stagingRoot) !== liveSkillsIdentity
+        liveStateIdentity !== null &&
+        preservedLiveStateIdentity(stagingRoot) !== liveStateIdentity
       ) {
-        throw new Error("live skills identity changed during staging");
+        throw new Error("live mutable state identity changed during staging");
       }
       const staged = validateNativeSlackCustomerProfile({
         desired,

package/lib/sellable-agent/provisioning-adapter.mjs

@@ -25,7 +25,7 @@ import { fileURLToPath } from "node:url";
 import { deriveContainedProfileId } from "./profile-materializer.mjs";
 
 export const PROVISIONING_ACTION = "PROVISION_HERMES_PROFILE";
-export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.597";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.599";
 export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.860";
 const PINNED_INSTALL_VERSION = PINNED_INSTALL_PACKAGE.slice(
   PINNED_INSTALL_PACKAGE.lastIndexOf("@") + 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.597",
+  "version": "0.1.599",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {