@sellable/install 0.1.579 → 0.1.581

package/lib/sellable-agent/hermes-bridge.mjs

@@ -1596,6 +1596,113 @@ export function patchHermesSourceFile(patchKind, source) {
     return patched;
   }
 
+  if (patchKind === "skills-cache-freshness-v020") {
+    let patched = replaceExactlyOnce(
+      source,
+      "        sig.append((str(d), m))",
+      [
+        "        skill_files = []",
+        "        for root, dirs, files in os.walk(d, followlinks=False):",
+        "            dirs[:] = sorted(",
+        "                name for name in dirs",
+        "                if not os.path.islink(os.path.join(root, name))",
+        "            )",
+        '            if "SKILL.md" not in files:',
+        "                continue",
+        '            skill_path = os.path.join(root, "SKILL.md")',
+        "            try:",
+        "                skill_stat = os.stat(skill_path, follow_symlinks=False)",
+        "                skill_files.append(",
+        "                    (skill_path, skill_stat.st_mtime_ns, skill_stat.st_size)",
+        "                )",
+        "            except OSError:",
+        "                continue",
+        "        sig.append((str(d), m, tuple(skill_files)))",
+      ].join("\n"),
+      "v0.20 live SKILL.md signature"
+    );
+    patched = replaceExactlyOnce(
+      patched,
+      "    disabled = set() if skip_disabled else _get_disabled_skill_names()",
+      [
+        "    disabled = _get_disabled_skill_names()",
+        "    filtered_disabled = set() if skip_disabled else disabled",
+      ].join("\n"),
+      "v0.20 shared disabled signature"
+    );
+    patched = replaceExactlyOnce(
+      patched,
+      "                if name in disabled:\n                    continue",
+      "                if name in filtered_disabled:\n                    continue",
+      "v0.20 filtered disabled behavior"
+    );
+    patched = replaceExactlyOnce(
+      patched,
+      "    skills = []\n    seen_names: set = set()",
+      [
+        "    # A signature change invalidates both filtered and unfiltered",
+        "    # variants together; neither waits for the 30-second TTL.",
+        "    if cached is not None and cached[0] != signature:",
+        "        _SKILLS_CACHE.clear()",
+        "",
+        "    skills = []",
+        "    seen_names: set = set()",
+      ].join("\n"),
+      "v0.20 both-variant cache invalidation"
+    );
+    return patched;
+  }
+
+  if (patchKind === "skills-prompt-freshness-v020") {
+    let patched = replaceExactlyOnce(
+      source,
+      "_SKILLS_PROMPT_CACHE_LOCK = threading.Lock()",
+      [
+        "_SKILLS_PROMPT_CACHE_LOCK = threading.Lock()",
+        "_SELLABLE_AGENT_SKILLS_PROMPT_SIGNATURE = None",
+      ].join("\n"),
+      "v0.20 prompt signature state"
+    );
+    patched = replaceExactlyOnce(
+      patched,
+      "    disabled = get_disabled_skill_names(_platform_hint or None)\n    cache_key = (",
+      [
+        "    disabled = get_disabled_skill_names(_platform_hint or None)",
+        "    signature_roots = [skills_dir, *external_dirs]",
+        "    live_signature = tuple(",
+        "        (",
+        "            str(root),",
+        "            tuple(",
+        "                (path, tuple(values))",
+        "                for path, values in sorted(_build_skills_manifest(root).items())",
+        "            ),",
+        "        )",
+        "        for root in signature_roots",
+        "        if root.exists()",
+        "    )",
+        "    cache_key = (",
+      ].join("\n"),
+      "v0.20 prompt live signature"
+    );
+    patched = replaceExactlyOnce(
+      patched,
+      "        tuple(sorted(compact_categories or ())),\n    )\n    with _SKILLS_PROMPT_CACHE_LOCK:\n        cached = _SKILLS_PROMPT_CACHE.get(cache_key)",
+      [
+        "        tuple(sorted(compact_categories or ())),",
+        "        live_signature,",
+        "    )",
+        "    global _SELLABLE_AGENT_SKILLS_PROMPT_SIGNATURE",
+        "    with _SKILLS_PROMPT_CACHE_LOCK:",
+        "        if _SELLABLE_AGENT_SKILLS_PROMPT_SIGNATURE != live_signature:",
+        "            _SKILLS_PROMPT_CACHE.clear()",
+        "            _SELLABLE_AGENT_SKILLS_PROMPT_SIGNATURE = live_signature",
+        "        cached = _SKILLS_PROMPT_CACHE.get(cache_key)",
+      ].join("\n"),
+      "v0.20 prompt cache invalidation"
+    );
+    return patched;
+  }
+
   throw new HermesAgentBridgeError(
     "HERMES_BRIDGE_UNKNOWN_PATCH_KIND",
     `Unknown Hermes bridge patch kind: ${patchKind}`,
@@ -1820,7 +1927,7 @@ export const HERMES_AGENT_BRIDGE_DEDICATED_V020_CONTRACT = normalizeContract({
       sourceSha256:
         "f9d50eec7b98819fa91b8ce640c8a32eff0726e0f349832763852bd82bbbb958",
       patchedSha256:
-        "0622b793e72967f16688b059dbecc22ecd91b78623792be0af37a2cdeb19404b",
+        "4b0bcc47a07a43402958bbd09524483f8adb370bcbfa6ffa99b63b4ca5b35ff1",
     },
     {
       path: "gateway/run.py",
@@ -1836,7 +1943,7 @@ export const HERMES_AGENT_BRIDGE_DEDICATED_V020_CONTRACT = normalizeContract({
       sourceSha256:
         "a0e136367b64007d7b49ea006ab0aa7dcc66b12134b512a463a03bd69fb8a90c",
       patchedSha256:
-        "670d05a11edf0f9174e84e6b8803ffc1f2522e138898a6f86cbfaff7e0e3e299",
+        "5f19a22c832db2e93b3da0fe9ea62606968233aa964318f8f81b0ae3dc7c8a13",
     },
     {
       path: "hermes_cli/web_routers/tools.py",
@@ -1852,7 +1959,23 @@ export const HERMES_AGENT_BRIDGE_DEDICATED_V020_CONTRACT = normalizeContract({
       sourceSha256:
         "aba4c2b9c8691ccc86518cfa10dcd92e55d7b2103c1c6807f54ddf58919f3f48",
       patchedSha256:
-        "90c98514a8c6c4078dacdd67a92cf749bd174ec2c074226163c6cb07ca3df59f",
+        "8302998c684a290eae1dd8c34f93c790ced764340d72d52995021b15625f0acb",
+    },
+    {
+      path: "tools/skills_tool.py",
+      patchKind: "skills-cache-freshness-v020",
+      sourceSha256:
+        "6cfe456c8872c91309083694290e5e2cbdb64a1b2f4ac9c2cb38973fab2228ab",
+      patchedSha256:
+        "9a1b1417879d9aac6d5b6e1713237193009e2d67dbc691db35ef5940e94f9397",
+    },
+    {
+      path: "agent/prompt_builder.py",
+      patchKind: "skills-prompt-freshness-v020",
+      sourceSha256:
+        "2a8a8b2b6c0ff830349f68b5c2f26bf2c9871ae03caf516cff3628c00b5769c7",
+      patchedSha256:
+        "4a55eb6dd4e79d35fca9fd02544444576c892ca02dfebb0c97954156cc470fdb",
     },
   ],
 });

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

@@ -39,8 +39,8 @@ 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.577";
-const MCP_PACKAGE = "@sellable/mcp@0.1.858";
+  "@sellable/install@0.1.581";
+const MCP_PACKAGE = "@sellable/mcp@0.1.859";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;
 const SHA256_16 = /^[a-f0-9]{16}$/;

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

@@ -29,6 +29,7 @@ import {
   relative,
   resolve,
 } from "node:path";
+import { readSkillsProofObservation } from "./fly-skills-bridge.mjs";
 import {
   commitRetainedProfilePromotion,
   computeAgentProfileDigest,
@@ -77,6 +78,11 @@ const SECRET_PATTERN =
   /sat_[A-Za-z0-9_-]+|xox[bap]-[A-Za-z0-9-]+|asec\.v1\.|authorization[_-]?code|access[_-]?token|refresh[_-]?token/i;
 const STATE_FILE = "worker-state.json";
 
+export function attachSkillsProofObservation(observed, profileRoot) {
+  const skills = readSkillsProofObservation(profileRoot);
+  return skills ? { ...observed, skills } : observed;
+}
+
 function stableJson(value) {
   if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
   if (value && typeof value === "object") {
@@ -1540,10 +1546,8 @@ export function compileClaimToProfileDesired(activeClaim, config) {
       ]) ||
       pinned.hermesCli !== "hermes" ||
       pinned.hermesVersion !== "0.18.0" ||
-      pinned.installerPackage !==
-        "@sellable/install@0.1.577" ||
-      pinned.mcpPackage !==
-        "@sellable/mcp@0.1.858" ||
+      pinned.installerPackage !== "@sellable/install@0.1.581" ||
+      pinned.mcpPackage !== "@sellable/mcp@0.1.859" ||
       !Array.isArray(policy.toolInclude) ||
       policy.toolInclude.length === 0 ||
       !Number.isSafeInteger(slack.generation) ||
@@ -2348,7 +2352,10 @@ export function createLocalPinnedActionPorts(config, dependencies = {}) {
       observed.process.uid !== config.runtimeUid
     )
       throw new Error("runtime observation identity rejected");
-    return observed;
+    return attachSkillsProofObservation(
+      observed,
+      join(realpathSync(config.profilesRoot), context.profileId)
+    );
   };
   const ensureRefreshTarget = async () => {
     if (refreshPrepared) return;

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

@@ -201,10 +201,8 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !==
-      "@sellable/install@0.1.577" ||
-    desired.mcpPackage !==
-      "@sellable/mcp@0.1.858" ||
+    desired.installerPackage !== "@sellable/install@0.1.581" ||
+    desired.mcpPackage !== "@sellable/mcp@0.1.859" ||
     !Array.isArray(desired.toolInclude) ||
     desired.toolInclude.length === 0 ||
     desired.toolInclude.some((tool) => !/^[a-z][a-z0-9_]{0,127}$/.test(tool)) ||
@@ -408,6 +406,113 @@ function configFor(desired, profileId) {
   };
 }
 
+const LIVE_SKILLS_CONFIG_KEYS = Object.freeze([
+  "disabled",
+  "platform_disabled",
+]);
+
+function profileConfigWithoutLiveSkills(value) {
+  const normalized = structuredClone(value);
+  if (
+    normalized?.skills &&
+    typeof normalized.skills === "object" &&
+    !Array.isArray(normalized.skills)
+  ) {
+    for (const key of LIVE_SKILLS_CONFIG_KEYS) delete normalized.skills[key];
+    if (Object.keys(normalized.skills).length === 0) delete normalized.skills;
+  }
+  return normalized;
+}
+
+function normalizedProfileConfigBytes(pathValue) {
+  const value = JSON.parse(readFileSync(pathValue, "utf8"));
+  return Buffer.from(
+    `${JSON.stringify(profileConfigWithoutLiveSkills(value), null, 2)}\n`,
+    "utf8"
+  );
+}
+
+function mergeLiveSkillsConfig(sourceRoot, targetRoot) {
+  const sourcePath = join(sourceRoot, "config.yaml");
+  const targetPath = join(targetRoot, "config.yaml");
+  if (!existsSync(sourcePath) || !existsSync(targetPath)) return;
+  const source = JSON.parse(readFileSync(sourcePath, "utf8"));
+  const target = JSON.parse(readFileSync(targetPath, "utf8"));
+  const sourceSkills = source?.skills;
+  if (
+    !sourceSkills ||
+    typeof sourceSkills !== "object" ||
+    Array.isArray(sourceSkills)
+  ) {
+    return;
+  }
+  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,
+  };
+  atomicWrite(
+    targetPath,
+    `${JSON.stringify(target, null, 2)}\n`,
+    lstatSync(targetPath).mode & 0o777
+  );
+}
+
+function mergeLiveSkillsState(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);
+}
+
+function preservedSkillsConfigIdentity(profileRoot) {
+  if (!existsSync(profileRoot)) return null;
+  const entries = [];
+  const skillsRoot = join(profileRoot, "skills");
+  const walk = (directory, relativePath = "") => {
+    for (const name of readdirSync(directory).sort()) {
+      const nextRelative = relativePath ? `${relativePath}/${name}` : name;
+      if (nextRelative === "sellable") continue;
+      const pathValue = join(directory, name);
+      const link = lstatSync(pathValue);
+      if (link.isSymbolicLink())
+        throw new Error("live skills symlink rejected");
+      if (link.isDirectory()) walk(pathValue, nextRelative);
+      else if (link.isFile()) {
+        entries.push({
+          path: nextRelative,
+          sha256: sha256(readFileSync(pathValue)),
+        });
+      } else throw new Error("live skills entry rejected");
+    }
+  };
+  if (existsSync(skillsRoot)) walk(skillsRoot);
+  const configPath = join(profileRoot, "config.yaml");
+  let disabled = {};
+  if (existsSync(configPath)) {
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    const skills = config?.skills;
+    if (skills && typeof skills === "object" && !Array.isArray(skills)) {
+      disabled = Object.fromEntries(
+        LIVE_SKILLS_CONFIG_KEYS.filter((key) =>
+          Object.prototype.hasOwnProperty.call(skills, key)
+        ).map((key) => [key, skills[key]])
+      );
+    }
+  }
+  return sha256(stableJson({ disabled, entries }));
+}
+
 function mcpFor(desired, profileId) {
   return {
     package: desired.mcpPackage,
@@ -616,10 +721,8 @@ function validateRuntimeOwnership(observed, runtimeIdentity) {
     "skills/sellable",
     "skills/sellable/SKILL.md",
   ].sort();
-  if (
-    stableJson(observed.entries.map((entry) => entry.path).sort()) !==
-    stableJson(expectedPaths)
-  ) {
+  const observedPaths = observed.entries.map((entry) => entry.path);
+  if (expectedPaths.some((pathValue) => !observedPaths.includes(pathValue))) {
     return false;
   }
   return observed.entries.every(
@@ -644,9 +747,16 @@ export function validateAgentProfileBundle({ profileRoot, desired }) {
       return { ok: false, code: "profile_path_invalid" };
     }
     const foundInventory = inventory(profileRoot);
+    const serverOwned = [...AGENT_PROFILE_INVENTORY].sort();
     if (
-      JSON.stringify(foundInventory) !==
-      JSON.stringify([...AGENT_PROFILE_INVENTORY].sort())
+      serverOwned.some(
+        (logicalPath) => !foundInventory.includes(logicalPath)
+      ) ||
+      foundInventory.some(
+        (logicalPath) =>
+          !serverOwned.includes(logicalPath) &&
+          !logicalPath.startsWith("skills/")
+      )
     ) {
       return { ok: false, code: "profile_inventory_open" };
     }
@@ -667,7 +777,11 @@ export function validateAgentProfileBundle({ profileRoot, desired }) {
         .sort()
         .map((logicalPath) => [
           logicalPath,
-          sha256(readFileSync(join(profileRoot, logicalPath))),
+          sha256(
+            logicalPath === "config.yaml"
+              ? normalizedProfileConfigBytes(join(profileRoot, logicalPath))
+              : readFileSync(join(profileRoot, logicalPath))
+          ),
         ])
     );
     if (stableJson(manifest.fileHashes) !== stableJson(expectedHashes)) {
@@ -686,7 +800,8 @@ export function validateAgentProfileBundle({ profileRoot, desired }) {
       readFileSync(join(profileRoot, "sellable", "mcp.json"), "utf8")
     );
     if (
-      stableJson(config) !== stableJson(configFor(desired, manifest.profileId))
+      stableJson(profileConfigWithoutLiveSkills(config)) !==
+      stableJson(configFor(desired, manifest.profileId))
     ) {
       return { ok: false, code: "config_drift" };
     }
@@ -1625,7 +1740,7 @@ async function rollback({
   return outcome;
 }
 
-export async function materializeAgentProfile(input = {}) {
+async function materializeAgentProfileLocked(input = {}) {
   const valid = validateDesired(input.desired);
   if (!valid.ok)
     return { ok: false, status: "DESIRED_REJECTED", code: valid.code };
@@ -1688,7 +1803,15 @@ export async function materializeAgentProfile(input = {}) {
       revisionId: desired.revisionId,
       fence: desired.fence,
     });
+    const liveSkillsIdentity = preservedSkillsConfigIdentity(profileRoot);
     renderStagedProfile(stagingRoot, desired);
+    mergeLiveSkillsState(profileRoot, stagingRoot);
+    if (
+      liveSkillsIdentity !== null &&
+      preservedSkillsConfigIdentity(stagingRoot) !== liveSkillsIdentity
+    ) {
+      throw new Error("live skills identity changed during staging");
+    }
     const staged = validateAgentProfileBundle({
       profileRoot: stagingRoot,
       desired,
@@ -2016,6 +2139,26 @@ export async function materializeAgentProfile(input = {}) {
   }
 }
 
+export async function materializeAgentProfile(input = {}) {
+  const valid = validateDesired(input.desired);
+  const root = traversableProfilesRoot(input.profilesRoot);
+  if (!valid.ok || !root) return materializeAgentProfileLocked(input);
+  const profileId = deriveContainedProfileId(
+    input.desired.workspaceId,
+    input.desired.agentId,
+    input.desired.hostId
+  );
+  try {
+    return await withProfileSoulLock(
+      profileId,
+      () => materializeAgentProfileLocked(input),
+      { dataRoot: basename(root) === "profiles" ? dirname(root) : root }
+    );
+  } catch {
+    return { ok: false, status: "LOCK_REJECTED", profileId };
+  }
+}
+
 export const NATIVE_SLACK_CUSTOMER_PROFILE_INVENTORY = Object.freeze([
   "agent-profile.json",
   "config.yaml",
@@ -2326,7 +2469,11 @@ export function validateNativeSlackCustomerProfile({ desired, profileRoot }) {
         link.isSymbolicLink() ||
         !link.isFile() ||
         (link.mode & 0o022) !== 0 ||
-        !readFileSync(pathValue).equals(Buffer.from(expected))
+        !(logicalPath === "config.yaml"
+          ? normalizedProfileConfigBytes(pathValue).equals(
+              Buffer.from(expected)
+            )
+          : readFileSync(pathValue).equals(Buffer.from(expected)))
       ) {
         return { ok: false, code: "native_slack_profile_file_drift" };
       }
@@ -2393,6 +2540,7 @@ export function materializeNativeSlackCustomerProfile({
         return { ok: false, code: "native_slack_profile_path_rejected" };
       }
       let soulBytes = Buffer.from(desired.soul, "utf8");
+      const liveSkillsIdentity = preservedSkillsConfigIdentity(activeRoot);
       if (existsSync(activeRoot)) {
         const soulPath = join(activeRoot, "SOUL.md");
         if (existsSync(soulPath)) {
@@ -2409,6 +2557,13 @@ export function materializeNativeSlackCustomerProfile({
         soulBytes
       );
       mergeHermesState(activeRoot, stagingRoot);
+      mergeLiveSkillsConfig(activeRoot, stagingRoot);
+      if (
+        liveSkillsIdentity !== null &&
+        preservedSkillsConfigIdentity(stagingRoot) !== liveSkillsIdentity
+      ) {
+        throw new Error("live skills identity changed during staging");
+      }
       const staged = validateNativeSlackCustomerProfile({
         desired,
         profileRoot: stagingRoot,

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

@@ -25,10 +25,8 @@ 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.577";
-export const PINNED_MCP_PACKAGE =
-  "@sellable/mcp@0.1.858";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.581";
+export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.859";
 
 export function deriveAgentProfileId(workspaceId, agentId, hostId) {
   return deriveContainedProfileId(workspaceId, agentId, hostId);
@@ -613,8 +611,7 @@ function inspectProvisionedProfile({
       !matchesReadback(manifest, request) ||
       manifest.serviceCredentialReference !== serviceCredentialReference ||
       manifest.installerPackage !== PINNED_INSTALL_PACKAGE ||
-      manifest.installerVersion !==
-        "0.1.577" ||
+      manifest.installerVersion !== "0.1.581" ||
       manifest.mcpPackage !== PINNED_MCP_PACKAGE ||
       manifest.credentialKeyVersion !== credentialKeyVersion ||
       !/^[a-f0-9]{16}$/.test(manifest.credentialFingerprint) ||
@@ -828,7 +825,7 @@ function successReceipt({
     subject: `agent-profile:${observed.profileId}`,
     cli: {
       installPackage: PINNED_INSTALL_PACKAGE,
-      installVersion: "0.1.577",
+      installVersion: "0.1.581",
       mcpPackage: PINNED_MCP_PACKAGE,
       command: "hermes profile bootstrap",
     },
@@ -876,7 +873,7 @@ function failure(code, stages, extra = {}, request = null) {
       : "agent-profile:unbound",
     cli: {
       installPackage: PINNED_INSTALL_PACKAGE,
-      installVersion: "0.1.577",
+      installVersion: "0.1.581",
       mcpPackage: PINNED_MCP_PACKAGE,
       command: "hermes profile bootstrap",
     },

package/package.json

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