@hasna/skills 0.10.50 → 0.10.52

package/bin/mcp.js

@@ -20019,7 +20019,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.50",
+    version: "0.10.52",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -38339,6 +38339,10 @@ function parse6(text) {
   need(root.entries.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.rows, "exceeds its settings field limit");
   return root;
 }
+function parseNativeJsonObject(text) {
+  need(typeof text === "string" && Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
+  return parse6(text);
+}
 function canonical(value) {
   if (value.kind === "object")
     return { kind: "object", entries: value.entries.map(([key, child]) => [key, canonical(child)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0) };
@@ -38538,8 +38542,216 @@ var init_sumi_settings_witness = __esm(() => {
   SUMI_DISCOVERY_PROJECTION_FIELDS = ["skills", "plugin", "plugins", "permissions"];
 });
 
+// src/lib/codex-native-compatibility.ts
+function supportsCodexNativeCapability(version2, capability) {
+  return typeof version2 === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version2) && MEASURED_CODEX_CAPABILITIES[version2].includes(capability);
+}
+var MEASURED_CODEX_CAPABILITIES, SUPPORTED_CODEX_HOOK_VERSIONS;
+var init_codex_native_compatibility = __esm(() => {
+  MEASURED_CODEX_CAPABILITIES = {
+    "codex-cli 0.153.0": ["hooks"],
+    "codex-cli 0.154.0": ["hooks"],
+    "codex-cli 0.155.0": ["hooks"],
+    "codex-cli 0.155.1": ["hooks"],
+    "codex-cli 0.156.1": ["hooks"],
+    "codex-cli 0.157.0": ["hooks"],
+    "codex-cli 0.157.1": ["hooks"],
+    "codex-cli 0.158.0": ["hooks"],
+    "codex-cli 0.159.0": ["hooks"],
+    "codex-cli 0.159.2": ["hooks", "qualified-skill-catalog"],
+    "codex-cli 0.160.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+    "codex-cli 0.160.1": ["hooks", "qualified-skill-catalog", "installed-plugin-review"]
+  };
+  SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version2) => supportsCodexNativeCapability(version2, "hooks")));
+});
+
+// src/lib/claude-marketplace-entry-witness.ts
+import { createHash as createHash3 } from "crypto";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute4, resolve as resolve3 } from "path";
+function need2(value, reason) {
+  if (!value)
+    throw new Error(`Claude marketplace entry witness ${reason}`);
+}
+function unknownKey(selector, path, key) {
+  throw new Error(path === null ? `${CLAUDE_MARKETPLACE_ENTRY_HASH_MODE}: unknown top-level key ${quote(bounded(key))} in ${selector.marketplace}` : `${CLAUDE_MARKETPLACE_ENTRY_HASH_MODE}: unknown key ${quote(child(path, key))} in ${selector.marketplace}`);
+}
+function knownKeys(object4, allowed, selector, path) {
+  for (const [key] of object4.entries)
+    if (!allowed.has(key))
+      unknownKey(selector, path, key);
+}
+function claudeMarketplaceEntrySourceValid(source) {
+  const path = source?.path;
+  return typeof path === "string" && path.length > 0 && path.length <= PATH_CHARACTERS && !/[\x00-\x1f\x7f]/.test(path) && isAbsolute4(path) && resolve3(path) === path && basename4(path) === "marketplace.json" && basename4(dirname5(path)) === ".claude-plugin" && typeof source.marketplace === "string" && NAME.test(source.marketplace) && !source.marketplace.includes("..") && typeof source.plugin === "string" && NAME.test(source.plugin);
+}
+function canonical2(value) {
+  if (value.kind === "string")
+    return JSON.stringify(value.value);
+  if (value.kind === "number" || value.kind === "literal")
+    return value.value;
+  if (value.kind === "array")
+    return "[" + value.items.map(canonical2).join(",") + "]";
+  return "{" + [...value.entries].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => JSON.stringify(key) + ":" + canonical2(item)).join(",") + "}";
+}
+function validateMarketplace(root, selector) {
+  knownKeys(root, MARKETPLACE_KEYS, selector, null);
+  const name = field(root, "name");
+  need2(isString(name) && name.value === selector.marketplace, "marketplace name does not match the reviewed binding");
+  for (const key of ["$schema", "description", "version"]) {
+    const value = field(root, key);
+    need2(value === undefined || isString(value), `has an invalid marketplace ${key}`);
+  }
+  const owner = field(root, "owner");
+  need2(owner === undefined || owner.kind === "object", "has an invalid marketplace owner");
+  const metadata = field(root, "metadata");
+  if (metadata !== undefined) {
+    need2(metadata.kind === "object", "has an invalid marketplace metadata object");
+    knownKeys(metadata, MARKETPLACE_METADATA_KEYS, selector, "metadata");
+    for (const [key, value] of metadata.entries)
+      need2(isString(value), `has an invalid marketplace metadata.${key}`);
+  }
+  const remove = field(root, "forceRemoveDeletedPlugins");
+  need2(remove === undefined || isBoolean(remove), "has an invalid forceRemoveDeletedPlugins value");
+  const cross = field(root, "allowCrossMarketplaceDependenciesOn");
+  need2(cross === undefined || stringArray(cross), "has an invalid allowCrossMarketplaceDependenciesOn value");
+  const renames = field(root, "renames");
+  if (renames !== undefined) {
+    need2(renames.kind === "object" && renames.entries.every(([, target]) => isString(target) || target.kind === "literal" && target.value === "null"), "has an invalid renames map");
+    need2(!renames.entries.some(([from]) => from.toLowerCase() === selector.plugin.toLowerCase()), "plugin id is redirected by the marketplace renames map");
+  }
+}
+function validateSource(source, selector, path) {
+  if (isString(source)) {
+    need2(source.value.length > 0, "has an empty plugin source");
+    return;
+  }
+  need2(source?.kind === "object", "has an invalid plugin source");
+  const type = field(source, "source");
+  need2(isString(type) && Object.hasOwn(SOURCE_KEYS, type.value), "has an unreviewed plugin source type");
+  knownKeys(source, new Set(SOURCE_KEYS[type.value]), selector, path);
+}
+function projectEntry(entry, selector) {
+  const path = `plugins[${selector.plugin}]`;
+  knownKeys(entry, { has: (key) => ENTRY_BOUND_KEYS.has(key) || ENTRY_OMITTED_KEYS.has(key) }, selector, path);
+  const name = field(entry, "name");
+  need2(isString(name) && name.value === selector.plugin, "selected entry name does not match");
+  validateSource(field(entry, "source"), selector, `${path}.source`);
+  for (const key of ["strict", "defaultEnabled"]) {
+    const value = field(entry, key);
+    need2(value === undefined || isBoolean(value), `has an invalid entry ${key}`);
+  }
+  const headersHelper = field(entry, "headersHelper");
+  need2(headersHelper === undefined || isString(headersHelper), "has an invalid entry headersHelper");
+  const experimental = field(entry, "experimental");
+  if (experimental !== undefined) {
+    need2(experimental.kind === "object", "has an invalid entry experimental object");
+    knownKeys(experimental, EXPERIMENTAL_KEYS, selector, `${path}.experimental`);
+  }
+  for (const key of ["$schema", "description", "version", "homepage", "license", "category", "displayName"]) {
+    const value = field(entry, key);
+    need2(value === undefined || isString(value), `has an invalid entry ${key}`);
+  }
+  for (const [key, keys] of [["author", new Set(["name", "email", "url"])], ["repository", new Set(["type", "url", "directory"])]]) {
+    const value = field(entry, key);
+    if (value?.kind === "object")
+      knownKeys(value, keys, selector, `${path}.${key}`);
+    need2(value === undefined || isString(value) || stringObject(value), `has an invalid entry ${key}`);
+  }
+  for (const key of ["keywords", "tags"]) {
+    const value = field(entry, key);
+    need2(value === undefined || stringArray(value), `has an invalid entry ${key}`);
+  }
+  const metadata = field(entry, "metadata");
+  need2(metadata === undefined || metadata.kind === "object", "has an invalid entry metadata object");
+  return { kind: "object", entries: entry.entries.filter(([key]) => ENTRY_BOUND_KEYS.has(key)) };
+}
+function hashClaudeMarketplaceEntry(text, selector) {
+  need2(selector && typeof selector.marketplace === "string" && NAME.test(selector.marketplace) && !selector.marketplace.includes("..") && typeof selector.plugin === "string" && NAME.test(selector.plugin), "requires an exact marketplace and plugin name");
+  let root;
+  try {
+    root = parseNativeJsonObject(text);
+  } catch (error61) {
+    throw new Error(`Claude marketplace entry witness cannot parse marketplace.json: ${reason(error61)}`);
+  }
+  validateMarketplace(root, selector);
+  const plugins = field(root, "plugins");
+  need2(plugins?.kind === "array", "requires a plugins array");
+  const entryName = (item) => {
+    if (item.kind !== "object")
+      return;
+    const name = field(item, "name");
+    return isString(name) ? name.value : undefined;
+  };
+  const exact = plugins.items.filter((item) => entryName(item) === selector.plugin);
+  const folded = plugins.items.filter((item) => entryName(item)?.toLowerCase() === selector.plugin.toLowerCase());
+  need2(exact.length > 0, "selected plugin entry is missing");
+  need2(exact.length === 1 && folded.length === 1, "selected plugin entry is duplicated or ambiguous");
+  const entry = projectEntry(exact[0], selector);
+  const metadata = field(root, "metadata"), pluginRoot = metadata?.kind === "object" ? field(metadata, "pluginRoot") : undefined;
+  const nullValue = { kind: "literal", value: "null" };
+  const marketplace = { kind: "object", entries: [
+    ["name", field(root, "name")],
+    ["pluginRoot", pluginRoot ?? nullValue],
+    ["allowCrossMarketplaceDependenciesOn", field(root, "allowCrossMarketplaceDependenciesOn") ?? nullValue]
+  ] };
+  const projection = { kind: "object", entries: [["marketplace", marketplace], ["plugin", entry]] };
+  return createHash3("sha256").update(DOMAIN).update(canonical2(projection)).digest("hex");
+}
+function captureClaudeMarketplaceEntry(path, marketplace, plugin, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  need2(claudeMarketplaceEntrySourceValid({ path, marketplace, plugin }), "requires a normalized absolute .claude-plugin/marketplace.json path and exact names");
+  let text;
+  try {
+    text = readNativeSettingsWitnessFile(path, budget2, "marketplace.json");
+  } catch (error61) {
+    throw new Error(`Claude marketplace entry witness cannot read marketplace.json: ${reason(error61)}`);
+  }
+  return { path, hashMode: CLAUDE_MARKETPLACE_ENTRY_HASH_MODE, marketplace, plugin, sha256: hashClaudeMarketplaceEntry(text, { marketplace, plugin }) };
+}
+var CLAUDE_MARKETPLACE_ENTRY_HASH_MODE = "claude-marketplace-entry-v1", DOMAIN = "hasna.skills.claude-marketplace-entry.v1\x00", PATH_CHARACTERS = 4096, NAME, bounded = (key) => key.length > 64 ? `${key.slice(0, 64)}...` : key, quote = (text) => JSON.stringify(text).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`), child = (path, key) => path + (/^[A-Za-z0-9_$-]{1,64}$/.test(key) ? `.${key}` : `[${JSON.stringify(bounded(key))}]`), reason = (error61) => String(error61?.message ?? error61).replace(/^Claude settings witness /, ""), MARKETPLACE_KEYS, MARKETPLACE_METADATA_KEYS, ENTRY_BOUND_KEYS, ENTRY_OMITTED_KEYS, EXPERIMENTAL_KEYS, SOURCE_KEYS, field = (object4, key) => object4.entries.find(([name]) => name === key)?.[1], isString = (value) => value?.kind === "string", isBoolean = (value) => value?.kind === "literal" && (value.value === "true" || value.value === "false"), stringArray = (value) => value?.kind === "array" && value.items.every(isString), stringObject = (value) => value?.kind === "object" && value.entries.every(([, item]) => isString(item));
+var init_claude_marketplace_entry_witness = __esm(() => {
+  init_claude_settings_witness();
+  NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+  MARKETPLACE_KEYS = new Set(["$schema", "name", "owner", "plugins", "description", "version", "metadata", "forceRemoveDeletedPlugins", "allowCrossMarketplaceDependenciesOn", "renames"]);
+  MARKETPLACE_METADATA_KEYS = new Set(["description", "version", "pluginRoot"]);
+  ENTRY_BOUND_KEYS = new Set([
+    "name",
+    "source",
+    "strict",
+    "defaultEnabled",
+    "dependencies",
+    "relevance",
+    "headers",
+    "headersHelper",
+    "settings",
+    "userConfig",
+    "types",
+    "channels",
+    "skills",
+    "commands",
+    "agents",
+    "hooks",
+    "mcpServers",
+    "lspServers",
+    "outputStyles",
+    "workflows",
+    "experimental",
+    "themes",
+    "monitors"
+  ]);
+  ENTRY_OMITTED_KEYS = new Set(["$schema", "description", "version", "author", "homepage", "repository", "license", "keywords", "category", "tags", "displayName", "metadata"]);
+  EXPERIMENTAL_KEYS = new Set(["themes", "monitors", "evals"]);
+  SOURCE_KEYS = Object.freeze({
+    github: ["source", "repo", "ref", "sha"],
+    url: ["source", "url", "ref", "sha", "path"],
+    "git-subdir": ["source", "url", "path", "ref", "sha"],
+    npm: ["source", "package", "version", "registry"],
+    archive: ["source", "url", "sha256"],
+    command: ["source", "command", "timeout", "mode"]
+  });
+});
+
 // src/lib/agent-policy-limits.ts
-import { basename as basename4, isAbsolute as isAbsolute4, join as join10, resolve as resolve3, sep as sep3 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute5, join as join10, resolve as resolve4, sep as sep3 } from "path";
 function object4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -38592,7 +38804,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(isAbsolute4(control.pluginParent) && resolve3(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
+      requireBound(isAbsolute5(control.pluginParent) && resolve4(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
       if (control.remotePluginId !== undefined)
         requireBound(typeof control.remotePluginId === "string" && /^[A-Za-z0-9_~-]{1,1024}$/.test(control.remotePluginId));
       if (control.skillsOnly !== undefined)
@@ -38604,16 +38816,24 @@ function assertAgentPolicyCollections(policy) {
     }
   if (bridge.codexInactivePlugins !== undefined) {
     const controls = array3(bridge.codexInactivePlugins, 4096), ids = new Set;
-    requireBound(controls.length === 0 || object4(bridge.codexPluginSkillReview) && bridge.codexPluginSkillReview.version === "codex-cli 0.160.0" && typeof bridge.codexPluginSkillReview.catalogSha256 === "string" && /^[a-f0-9]{64}$/.test(bridge.codexPluginSkillReview.catalogSha256));
+    requireBound(controls.length === 0 || object4(bridge.codexPluginSkillReview) && supportsCodexNativeCapability(bridge.codexPluginSkillReview.version, "installed-plugin-review") && typeof bridge.codexPluginSkillReview.catalogSha256 === "string" && /^[a-f0-9]{64}$/.test(bridge.codexPluginSkillReview.catalogSha256));
     for (const control of controls) {
       requireBound(object4(control) && Object.keys(control).every((key) => ["pluginId", "namespace", "pluginParent", "sourceType", "sourceSha256"].includes(key)));
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(!ids.has(control.pluginId) && isAbsolute4(control.pluginParent) && resolve3(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
+      requireBound(!ids.has(control.pluginId) && isAbsolute5(control.pluginParent) && resolve4(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
       ids.add(control.pluginId);
     }
   }
+  if (bridge.discoveryExecutables !== undefined)
+    for (const [agent, executable] of Object.entries(record3(bridge.discoveryExecutables, AGENT_POLICY_LIMITS.agents))) {
+      requireBound(agent === "gemini" && object4(executable) && Object.keys(executable).length === 3 && executable.command === "gemini");
+      for (const path of [executable.path, executable.target]) {
+        text(path);
+        requireBound(!/[\x00-\x1f\x7f-\x9f\u200e\u200f\u202a-\u202e\u2066-\u2069]/.test(path) && isAbsolute5(path) && resolve4(path) === path);
+      }
+    }
   if (bridge.disabledBuiltins !== undefined)
     for (const builtin of array3(bridge.disabledBuiltins, AGENT_POLICY_LIMITS.builtinNames)) {
       requireBound(object4(builtin));
@@ -38639,11 +38859,11 @@ function assertAgentPolicyCollections(policy) {
       requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && Object.keys(proof).every((key) => ["roots", "parents", "directories"].includes(key)) && roots.length + parents2.length > 0 && new Set(roots).size === roots.length && new Set(parents2).size === parents2.length);
       for (const root of roots) {
         text(root);
-        requireBound(isAbsolute4(root) && resolve3(root) === root);
+        requireBound(isAbsolute5(root) && resolve4(root) === root);
       }
       for (const parent of parents2) {
         text(parent);
-        requireBound(isAbsolute4(parent) && resolve3(parent) === parent);
+        requireBound(isAbsolute5(parent) && resolve4(parent) === parent);
       }
       for (const directory of array3(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
         requireBound(object4(directory));
@@ -38656,14 +38876,14 @@ function assertAgentPolicyCollections(policy) {
     }
     if (value.codexInstallationInputs !== undefined) {
       const proof = record3(value.codexInstallationInputs, 4), inputs = array3(proof.plugins, 4096), ids = new Set;
-      requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && proof.version === "codex-cli 0.160.0" && typeof proof.catalogSha256 === "string" && /^[a-f0-9]{64}$/.test(proof.catalogSha256) && inputs.length > 0 && object4(bridge.codexPluginSkillReview) && bridge.codexPluginSkillReview.version === proof.version && bridge.codexPluginSkillReview.catalogSha256 === proof.catalogSha256);
+      requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && supportsCodexNativeCapability(proof.version, "installed-plugin-review") && typeof proof.catalogSha256 === "string" && /^[a-f0-9]{64}$/.test(proof.catalogSha256) && inputs.length > 0 && object4(bridge.codexPluginSkillReview) && bridge.codexPluginSkillReview.version === proof.version && bridge.codexPluginSkillReview.catalogSha256 === proof.catalogSha256);
       for (const input2 of inputs) {
         requireBound(object4(input2) && Object.keys(input2).every((key) => ["pluginId", "namespace", "pluginParent", "sourceRoot", "sourceSha256"].includes(key)));
         text(input2.pluginId, 1024);
         text(input2.namespace, 64);
         text(input2.pluginParent);
         text(input2.sourceRoot);
-        requireBound(!ids.has(input2.pluginId) && [input2.pluginParent, input2.sourceRoot].every((path) => isAbsolute4(path) && resolve3(path) === path) && typeof input2.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input2.sourceSha256));
+        requireBound(!ids.has(input2.pluginId) && [input2.pluginParent, input2.sourceRoot].every((path) => isAbsolute5(path) && resolve4(path) === path) && typeof input2.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input2.sourceSha256));
         ids.add(input2.pluginId);
       }
       if (proof.directories !== undefined)
@@ -38680,17 +38900,19 @@ function assertAgentPolicyCollections(policy) {
       text(source.path);
       requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
       if (source.hashMode !== undefined)
-        requireBound(["bytes", "path-bytes", "claude-plugin-manifest-v1", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "sumi-settings-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+        requireBound(["bytes", "path-bytes", "claude-plugin-manifest-v1", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "sumi-settings-v1", "claude-marketplace-entry-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
       if (source.hashMode === "claude-plugin-manifest-v1")
-        requireBound(agent === "claude" && value.agent === "claude" && ["automatic", "reviewed"].includes(value.method) && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && source.path.endsWith(join10(sep3, ".claude-plugin", "plugin.json")) && source.managedPlugins === undefined);
+        requireBound(agent === "claude" && value.agent === "claude" && ["automatic", "reviewed"].includes(value.method) && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve4(source.path) === source.path && source.path.endsWith(join10(sep3, ".claude-plugin", "plugin.json")) && source.managedPlugins === undefined);
       if (source.hashMode === "sumi-settings-v1")
-        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "sumi.json");
+        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve4(source.path) === source.path && basename5(source.path) === "sumi.json");
       if (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4"))
-        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "config.toml");
+        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve4(source.path) === source.path && basename5(source.path) === "config.toml");
       if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4"))
-        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "settings.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve4(source.path) === source.path && basename5(source.path) === "settings.json");
       if (source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2")
-        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "known_marketplaces.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve4(source.path) === source.path && basename5(source.path) === "known_marketplaces.json");
+      if (source.hashMode === "claude-marketplace-entry-v1")
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && claudeMarketplaceEntrySourceValid(source));
       if (source.hashMode === "claude-plugin-registry") {
         requireBound(agent === "claude");
         const managed = array3(source.managedPlugins, 64);
@@ -38705,8 +38927,8 @@ function assertAgentPolicyCollections(policy) {
       if (source.format !== undefined)
         requireBound(["json", "toml", "yaml"].includes(source.format));
       if (source.fields !== undefined)
-        for (const field of array3(source.fields, AGENT_POLICY_LIMITS.fields))
-          text(field, 256);
+        for (const field2 of array3(source.fields, AGENT_POLICY_LIMITS.fields))
+          text(field2, 256);
     }
     if (value.directories !== undefined)
       for (const directory of array3(value.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
@@ -38721,6 +38943,8 @@ function assertAgentPolicyCollections(policy) {
 }
 var AGENT_POLICY_LIMITS;
 var init_agent_policy_limits = __esm(() => {
+  init_codex_native_compatibility();
+  init_claude_marketplace_entry_witness();
   AGENT_POLICY_LIMITS = Object.freeze({ bytes: 1024 * 1024, agents: 16, discoverySources: 2048, discoveryRawSourceBytes: 64 * 1024 * 1024, discoveryRawTotalBytes: 256 * 1024 * 1024, discoveryPathLinks: 40, discoveryPathSteps: 256, discoveryPathSourceMetadataBytes: 64 * 1024, discoveryPathTotalMetadataBytes: 8 * 1024 * 1024, discoveryRoots: 512, discoveryDirectories: 64, discoveryDirectoryEntries: 20000, discoveryDirectoryBytes: 8 * 1024 * 1024, builtinNames: 2048, rootAliases: 2, fields: 64, pathCharacters: 4096 });
 });
 
@@ -43945,8 +44169,8 @@ var require_cst_visit = __commonJS((exports) => {
   visit2.REMOVE = REMOVE;
   visit2.itemAtPath = (cst, path) => {
     let item = cst;
-    for (const [field, index] of path) {
-      const tok = item?.[field];
+    for (const [field2, index] of path) {
+      const tok = item?.[field2];
       if (tok && "items" in tok) {
         item = tok.items[index];
       } else
@@ -43956,8 +44180,8 @@ var require_cst_visit = __commonJS((exports) => {
   };
   visit2.parentCollection = (cst, path) => {
     const parent = visit2.itemAtPath(cst, path.slice(0, -1));
-    const field = path[path.length - 1][0];
-    const coll = parent?.[field];
+    const field2 = path[path.length - 1][0];
+    const coll = parent?.[field2];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
@@ -43966,11 +44190,11 @@ var require_cst_visit = __commonJS((exports) => {
     let ctrl = visitor(item, path);
     if (typeof ctrl === "symbol")
       return ctrl;
-    for (const field of ["key", "value"]) {
-      const token = item[field];
+    for (const field2 of ["key", "value"]) {
+      const token = item[field2];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path.concat([[field2, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -43980,7 +44204,7 @@ var require_cst_visit = __commonJS((exports) => {
             i -= 1;
           }
         }
-        if (typeof ctrl === "function" && field === "key")
+        if (typeof ctrl === "function" && field2 === "key")
           ctrl = ctrl(item, path);
       }
     }
@@ -44406,9 +44630,9 @@ var require_lexer = __commonJS((exports) => {
       }
     }
     *parseQuotedScalar() {
-      const quote = this.charAt(0);
-      let end = this.buffer.indexOf(quote, this.pos + 1);
-      if (quote === "'") {
+      const quote2 = this.charAt(0);
+      let end = this.buffer.indexOf(quote2, this.pos + 1);
+      if (quote2 === "'") {
         while (end !== -1 && this.buffer[end + 1] === "'")
           end = this.buffer.indexOf("'", end + 2);
       } else {
@@ -45715,7 +45939,7 @@ var init_dist = __esm(() => {
 });
 
 // src/lib/agent-hermes.ts
-import { dirname as dirname5, isAbsolute as isAbsolute5, join as join11, resolve as resolve4 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join11, resolve as resolve5 } from "path";
 function object5(value) {
   return Boolean(value && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
 }
@@ -45749,7 +45973,7 @@ function assertHermesEnvironment(home) {
       throw new Error(`NATIVE_SKILL_DRIFT: Hermes ${variable} requires a dedicated discovery adapter; unset it before using this adapter`);
   }
   const selected = process.env.HERMES_HOME?.trim();
-  if (selected && (!isAbsolute5(selected) || resolve4(selected) !== join11(resolve4(home), ".hermes")))
+  if (selected && (!isAbsolute6(selected) || resolve5(selected) !== join11(resolve5(home), ".hermes")))
     throw new Error("NATIVE_SKILL_DRIFT: custom Hermes homes/profiles require their own reviewed bridge");
   if (process.env.HERMES_ENABLE_PROJECT_PLUGINS?.trim() && !["0", "false", "no", "off"].includes(process.env.HERMES_ENABLE_PROJECT_PLUGINS.trim().toLowerCase()))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes project plugins require a dedicated discovery review");
@@ -45759,18 +45983,18 @@ var init_agent_hermes = __esm(() => {
 });
 
 // src/lib/agent-discovery-directories.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { lstatSync as lstatSync6, opendirSync } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute6, join as join12, resolve as resolve5 } from "path";
-function need2(value, message) {
+import { dirname as dirname7, isAbsolute as isAbsolute7, join as join12, resolve as resolve6 } from "path";
+function need3(value, message) {
   if (!value)
     throw new Error(message);
 }
 function safe(path) {
-  need2(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute6(path) && resolve5(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
-  for (let cursor = path;; cursor = dirname6(cursor)) {
-    need2(!lstatSync6(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
-    if (dirname6(cursor) === cursor)
+  need3(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute7(path) && resolve6(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
+  for (let cursor = path;; cursor = dirname7(cursor)) {
+    need3(!lstatSync6(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
+    if (dirname7(cursor) === cursor)
       break;
   }
 }
@@ -45784,45 +46008,45 @@ function capture(path, budget2, excludedRoots, omittedRoots = [], rows) {
   const root = lstatSync6(path, { throwIfNoEntry: false });
   if (!root)
     return { path, sha256: null };
-  need2(root.isDirectory(), "Unsupported native discovery directory input");
-  const hash2 = createHash3("sha256");
+  need3(root.isDirectory(), "Unsupported native discovery directory input");
+  const hash2 = createHash4("sha256");
   function walk(current, relative3, before, depth) {
-    need2(depth <= 64, "Native discovery directory depth limit exceeded");
+    need3(depth <= 64, "Native discovery directory depth limit exceeded");
     const names = [], directory = opendirSync(current);
     try {
       for (let entry = directory.readSync();entry; entry = directory.readSync()) {
-        need2(++budget2.entries <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Native discovery directory entry limit exceeded");
+        need3(++budget2.entries <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Native discovery directory entry limit exceeded");
         names.push(entry.name);
       }
     } finally {
       directory.closeSync();
     }
-    need2(new Set(names).size === names.length, "Ambiguous native discovery directory names");
+    need3(new Set(names).size === names.length, "Ambiguous native discovery directory names");
     for (const name of names.sort()) {
-      const child = join12(current, name), childRelative = relative3 ? `${relative3}/${name}` : name;
-      if (omittedRoots.includes(child))
+      const child2 = join12(current, name), childRelative = relative3 ? `${relative3}/${name}` : name;
+      if (omittedRoots.includes(child2))
         continue;
-      need2(child.length <= AGENT_POLICY_LIMITS.pathCharacters, "Native discovery directory path limit exceeded");
-      const stat = lstatSync6(child);
-      need2(stat.isFile() || stat.isDirectory(), "Refusing symlink or special native discovery directory member");
+      need3(child2.length <= AGENT_POLICY_LIMITS.pathCharacters, "Native discovery directory path limit exceeded");
+      const stat = lstatSync6(child2);
+      need3(stat.isFile() || stat.isDirectory(), "Refusing symlink or special native discovery directory member");
       const row = JSON.stringify([childRelative, stat.isDirectory() ? "directory" : "file"]) + `
 `;
       budget2.bytes += Buffer.byteLength(row);
-      need2(budget2.bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Native discovery directory metadata limit exceeded");
+      need3(budget2.bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Native discovery directory metadata limit exceeded");
       hash2.update(row);
       rows?.push(row);
-      if (stat.isDirectory() && !excludedRoots.includes(child))
-        walk(child, childRelative, stat, depth + 1);
+      if (stat.isDirectory() && !excludedRoots.includes(child2))
+        walk(child2, childRelative, stat, depth + 1);
     }
-    need2(same(before, lstatSync6(current, { throwIfNoEntry: false })), "Native discovery directory changed while reading");
+    need3(same(before, lstatSync6(current, { throwIfNoEntry: false })), "Native discovery directory changed while reading");
   }
   walk(path, "", root, 0);
   safe(path);
   return { path, sha256: hash2.digest("hex") };
 }
 function captureDiscoveryDirectoryProjection(paths, omittedRoots) {
-  need2(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid projected discovery directory collection");
-  need2(omittedRoots.length <= AGENT_POLICY_LIMITS.discoveryRoots && new Set(omittedRoots).size === omittedRoots.length, "Invalid inactive discovery roots");
+  need3(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid projected discovery directory collection");
+  need3(omittedRoots.length <= AGENT_POLICY_LIMITS.discoveryRoots && new Set(omittedRoots).size === omittedRoots.length, "Invalid inactive discovery roots");
   for (const root of omittedRoots)
     safe(root);
   const budget2 = { entries: 0, bytes: 0 };
@@ -45832,65 +46056,65 @@ function captureDiscoveryDirectoryProjection(paths, omittedRoots) {
   });
 }
 function verifyDiscoveryDirectoryProjection(directories, omittedRoots) {
-  need2(directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid projected discovery directory collection");
+  need3(directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid projected discovery directory collection");
   let count = 0, bytes = 0;
   const expected = directories.map((directory) => {
     safe(directory.path);
-    need2(Array.isArray(directory.entries), "Missing reviewed directory membership inventory");
-    const hash2 = createHash3("sha256");
+    need3(Array.isArray(directory.entries), "Missing reviewed directory membership inventory");
+    const hash2 = createHash4("sha256");
     const kept = [];
     for (const row of directory.entries) {
-      need2(typeof row === "string" && ++count <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Invalid reviewed directory membership rows");
+      need3(typeof row === "string" && ++count <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Invalid reviewed directory membership rows");
       bytes += Buffer.byteLength(row);
-      need2(bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Reviewed directory membership byte limit exceeded");
+      need3(bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Reviewed directory membership byte limit exceeded");
       const value = JSON.parse(row);
-      need2(Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0] && !isAbsolute6(value[0]) && !value[0].split("/").some((part) => !part || part === "." || part === "..") && ["file", "directory"].includes(value[1]) && row === JSON.stringify(value) + `
+      need3(Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0] && !isAbsolute7(value[0]) && !value[0].split("/").some((part) => !part || part === "." || part === "..") && ["file", "directory"].includes(value[1]) && row === JSON.stringify(value) + `
 `, "Invalid reviewed directory member");
       hash2.update(row);
       const path = join12(directory.path, value[0]);
       if (!omittedRoots.some((root) => path === root || path.startsWith(root + "/")))
         kept.push(row);
     }
-    need2(directory.sha256 === null ? directory.entries.length === 0 : hash2.digest("hex") === directory.sha256, "Reviewed directory inventory does not match its fingerprint");
+    need3(directory.sha256 === null ? directory.entries.length === 0 : hash2.digest("hex") === directory.sha256, "Reviewed directory inventory does not match its fingerprint");
     const absent = omittedRoots.some((root) => directory.path === root || directory.path.startsWith(root + "/"));
-    return { path: directory.path, sha256: absent || directory.sha256 === null ? null : createHash3("sha256").update(kept.join("")).digest("hex") };
+    return { path: directory.path, sha256: absent || directory.sha256 === null ? null : createHash4("sha256").update(kept.join("")).digest("hex") };
   });
   const current = captureDiscoveryDirectoryProjection(directories.map((item) => item.path), omittedRoots);
-  need2(current.every((item, index) => item.sha256 === expected[index].sha256), "Native discovery directory membership changed outside retired Codex roots");
+  need3(current.every((item, index) => item.sha256 === expected[index].sha256), "Native discovery directory membership changed outside retired Codex roots");
 }
 function captureDiscoveryDirectories(paths, excludedRoots = []) {
-  need2(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid native discovery directory collection");
+  need3(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid native discovery directory collection");
   const budget2 = { entries: 0, bytes: 0 };
   for (const root of excludedRoots)
     safe(root);
   return paths.map((path) => capture(path, budget2, excludedRoots));
 }
 function verifyDiscoveryDirectories(directories, excludedRoots = []) {
-  need2(Array.isArray(directories) && directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid native discovery directory collection");
+  need3(Array.isArray(directories) && directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid native discovery directory collection");
   for (const directory of directories)
-    need2(directory && typeof directory === "object" && (directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256)), "Invalid native discovery directory digest");
+    need3(directory && typeof directory === "object" && (directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256)), "Invalid native discovery directory digest");
   const current = captureDiscoveryDirectories(directories.map((directory) => directory.path), excludedRoots);
   for (let i = 0;i < directories.length; i++)
-    need2(current[i].sha256 === directories[i].sha256, `Native discovery directory membership changed; run skills hook install with a fresh discovery review: ${directories[i].path}`);
+    need3(current[i].sha256 === directories[i].sha256, `Native discovery directory membership changed; run skills hook install with a fresh discovery review: ${directories[i].path}`);
 }
 var init_agent_discovery_directories = __esm(() => {
   init_agent_policy_limits();
 });
 
 // src/lib/agent-discovery-bytes.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { closeSync as closeSync6, constants as constants3, fstatSync as fstatSync6, lstatSync as lstatSync7, openSync as openSync6, readSync as readSync3 } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute7, resolve as resolve6 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute8, resolve as resolve7 } from "path";
 function discoveryByteBudget() {
   return { remaining: AGENT_POLICY_LIMITS.discoveryRawTotalBytes };
 }
 function safe2(path) {
-  if (typeof path !== "string" || !isAbsolute7(path) || path !== resolve6(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
+  if (typeof path !== "string" || !isAbsolute8(path) || path !== resolve7(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
     throw new Error("Expected a canonical absolute raw discovery path");
-  for (let cursor = path;; cursor = dirname7(cursor)) {
+  for (let cursor = path;; cursor = dirname8(cursor)) {
     if (lstatSync7(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("Refusing symlink raw discovery input");
-    if (dirname7(cursor) === cursor)
+    if (dirname8(cursor) === cursor)
       break;
   }
 }
@@ -45909,7 +46133,7 @@ function hashRawDiscoveryFile(path, budget2, changes) {
     if (bytes > AGENT_POLICY_LIMITS.discoveryRawSourceBytes)
       throw new Error("Raw discovery file byte limit exceeded");
     consume(budget2, bytes);
-    return createHash4("sha256").update(text2).digest("hex");
+    return createHash5("sha256").update(text2).digest("hex");
   }
   const initial = lstatSync7(path, { throwIfNoEntry: false });
   if (!initial)
@@ -45923,7 +46147,7 @@ function hashRawDiscoveryFile(path, budget2, changes) {
     const opened = fstatSync6(fd);
     if (!opened.isFile() || !same2(initial, opened))
       throw new Error("Raw discovery input changed during open");
-    const hash2 = createHash4("sha256"), buffer = Buffer.alloc(64 * 1024);
+    const hash2 = createHash5("sha256"), buffer = Buffer.alloc(64 * 1024);
     let bytes = 0;
     while (true) {
       const count = readSync3(fd, buffer, 0, Math.min(buffer.length, AGENT_POLICY_LIMITS.discoveryRawSourceBytes - bytes + 1), null);
@@ -45949,9 +46173,9 @@ var init_agent_discovery_bytes = __esm(() => {
 });
 
 // src/lib/agent-discovery-path-bytes.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { lstatSync as lstatSync8, readlinkSync } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute8, join as join13, parse as parse7, resolve as resolve7, sep as sep4 } from "path";
+import { dirname as dirname9, isAbsolute as isAbsolute9, join as join13, parse as parse7, resolve as resolve8, sep as sep4 } from "path";
 function identity2(stat, mutable = false) {
   return {
     dev: String(stat.dev),
@@ -45962,12 +46186,12 @@ function identity2(stat, mutable = false) {
     ...mutable ? { size: String(stat.size), mtimeNs: String(stat.mtimeNs), ctimeNs: String(stat.ctimeNs) } : {}
   };
 }
-function canonical2(path) {
-  if (typeof path !== "string" || !isAbsolute8(path) || path !== resolve7(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
+function canonical3(path) {
+  if (typeof path !== "string" || !isAbsolute9(path) || path !== resolve8(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
     throw new Error("Expected a canonical absolute discovery path");
 }
 function trace(path) {
-  canonical2(path);
+  canonical3(path);
   const rows = [], paths = [];
   let metadataBytes = 0, steps = 0, links = 0, cursor = parse7(path).root, pending = path.slice(cursor.length).split(sep4);
   function record4(path2, row) {
@@ -45992,7 +46216,7 @@ function trace(path) {
     if (!component || component === ".")
       continue;
     if (component === "..") {
-      cursor = dirname8(cursor);
+      cursor = dirname9(cursor);
       continue;
     }
     const candidate = join13(cursor, component);
@@ -46012,11 +46236,11 @@ function trace(path) {
       if (!target || target.includes("\x00") || Buffer.byteLength(target) > AGENT_POLICY_LIMITS.pathCharacters || !after.isSymbolicLink() || JSON.stringify(identity2(stat, true)) !== JSON.stringify(identity2(after, true)))
         throw new Error("Discovery link changed during read");
       record4(candidate, { type: "link", target, ...identity2(stat, true) });
-      if (isAbsolute8(target)) {
+      if (isAbsolute9(target)) {
         cursor = parse7(target).root;
         root();
       }
-      const remainder = isAbsolute8(target) ? target.slice(parse7(target).root.length) : target;
+      const remainder = isAbsolute9(target) ? target.slice(parse7(target).root.length) : target;
       pending = [...remainder.split(sep4), ...pending];
       if (pending.length + steps > AGENT_POLICY_LIMITS.discoveryPathSteps)
         throw new Error("Discovery path step limit exceeded");
@@ -46059,7 +46283,7 @@ function hashDiscoveryPathFile(path, budget2, changes) {
   const after = trace(path);
   if (JSON.stringify(before.rows) !== JSON.stringify(after.rows) || before.file !== after.file)
     throw new Error("Discovery path input changed during read");
-  return createHash5("sha256").update(JSON.stringify({ version: 1, path, rows: before.rows, content })).digest("hex");
+  return createHash6("sha256").update(JSON.stringify({ version: 1, path, rows: before.rows, content })).digest("hex");
 }
 var init_agent_discovery_path_bytes = __esm(() => {
   init_agent_policy_limits();
@@ -46067,10 +46291,10 @@ var init_agent_discovery_path_bytes = __esm(() => {
 });
 
 // src/lib/claude-plugin-manifest-witness.ts
-import { createHash as createHash6 } from "crypto";
-function requireValue(value, reason) {
+import { createHash as createHash7 } from "crypto";
+function requireValue(value, reason2) {
   if (!value)
-    throw new Error("Claude plugin manifest " + reason);
+    throw new Error("Claude plugin manifest " + reason2);
 }
 function parse8(text2) {
   requireValue(Buffer.byteLength(text2, "utf8") <= CLAUDE_PLUGIN_MANIFEST_LIMITS.bytes, "exceeds its byte limit");
@@ -46146,7 +46370,7 @@ function parse8(text2) {
   requireValue(at === text2.length && root.kind === "object", "requires a JSON object without trailing content");
   return root;
 }
-function canonical3(value) {
+function canonical4(value) {
   if (value.kind === "string")
     return JSON.stringify(value.value);
   if (value.kind === "number")
@@ -46154,18 +46378,18 @@ function canonical3(value) {
   if (value.kind === "literal")
     return value.value;
   if (value.kind === "array")
-    return "[" + value.items.map(canonical3).join(",") + "]";
-  return "{" + value.entries.map(([key, item]) => JSON.stringify(key) + ":" + canonical3(item)).join(",") + "}";
+    return "[" + value.items.map(canonical4).join(",") + "]";
+  return "{" + value.entries.map(([key, item]) => JSON.stringify(key) + ":" + canonical4(item)).join(",") + "}";
 }
-function validateText(value, field) {
-  requireValue(value?.kind === "string" && value.value.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters, "has an invalid " + field + " field");
+function validateText(value, field2) {
+  requireValue(value?.kind === "string" && value.value.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters, "has an invalid " + field2 + " field");
 }
 function validateDescriptiveFields(manifest) {
   const values = new Map(manifest.entries);
-  for (const field of ["description", "version", "homepage", "license"]) {
-    const value = values.get(field);
+  for (const field2 of ["description", "version", "homepage", "license"]) {
+    const value = values.get(field2);
     if (value !== undefined)
-      validateText(value, field);
+      validateText(value, field2);
   }
   const author = values.get("author");
   if (author !== undefined) {
@@ -46190,10 +46414,10 @@ function hashClaudePluginManifest(text2) {
   const manifest = parse8(text2);
   validateDescriptiveFields(manifest);
   const discovery = { kind: "object", entries: manifest.entries.filter(([key]) => !DESCRIPTIVE_FIELDS.has(key)) };
-  return createHash6("sha256").update(canonical3(discovery)).digest("hex");
+  return createHash7("sha256").update(canonical4(discovery)).digest("hex");
 }
 function projectReviewedClaudePluginManifest(text2, reviewedSha256) {
-  if (!/^[a-f0-9]{64}$/.test(reviewedSha256) || createHash6("sha256").update(text2).digest("hex") !== reviewedSha256) {
+  if (!/^[a-f0-9]{64}$/.test(reviewedSha256) || createHash7("sha256").update(text2).digest("hex") !== reviewedSha256) {
     throw new Error("Reviewed Claude plugin manifest changed before semantic projection");
   }
   return hashClaudePluginManifest(text2);
@@ -46205,7 +46429,7 @@ var init_claude_plugin_manifest_witness = __esm(() => {
 });
 
 // src/lib/skill-bundle.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { readFileSync as readFileSync9, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
 import { join as join14, relative as relative3 } from "path";
 import { createGunzip } from "zlib";
@@ -46237,7 +46461,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash8("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -46365,12 +46589,12 @@ function inspectionLimits(options) {
   for (const key of Object.keys(options.limits ?? {})) {
     if (!Object.hasOwn(limits, key))
       throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Unknown bundle limit");
-    const field = key;
-    const value = options.limits[field];
-    if (!Number.isSafeInteger(value) || value <= 0 || value > limits[field]) {
+    const field2 = key;
+    const value = options.limits[field2];
+    if (!Number.isSafeInteger(value) || value <= 0 || value > limits[field2]) {
       throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Bundle limits must be positive integers within the hard ceilings");
     }
-    limits[field] = value;
+    limits[field2] = value;
   }
   return limits;
 }
@@ -46400,7 +46624,14 @@ async function inspectSkillBundle(bundle, options = {}) {
     decoder.destroy(terminalError);
   };
   const onAbort = () => stop("BUNDLE_ABORTED");
-  const timer = setTimeout(() => stop("BUNDLE_TIMEOUT"), Math.max(1, deadline - performance.now()));
+  const expire = () => {
+    const remaining = deadline - performance.now();
+    if (remaining > 0)
+      timer = setTimeout(expire, Math.max(1, Math.ceil(remaining)));
+    else
+      stop("BUNDLE_TIMEOUT");
+  };
+  let timer = setTimeout(expire, Math.max(1, Math.ceil(deadline - performance.now())));
   signal?.addEventListener("abort", onAbort, { once: true });
   let decompressedByteSize = 0;
   let bytesSinceYield = 0;
@@ -46415,7 +46646,7 @@ async function inspectSkillBundle(bundle, options = {}) {
       parser2.push(chunk);
       bytesSinceYield += chunk.byteLength;
       if (bytesSinceYield >= 256 * 1024) {
-        await new Promise((resolve8) => setTimeout(resolve8, 0));
+        await new Promise((resolve9) => setTimeout(resolve9, 0));
         bytesSinceYield = 0;
         check2();
       }
@@ -46552,8 +46783,8 @@ class BoundedTarReader {
     }
   }
 }
-function tarOctal(field) {
-  const text2 = new TextDecoder().decode(field);
+function tarOctal(field2) {
+  const text2 = new TextDecoder().decode(field2);
   if (!/^[0-7]+[\0 ]*$/.test(text2))
     invalidBundle("Invalid tar octal field");
   const value = Number.parseInt(text2, 8);
@@ -46772,21 +47003,21 @@ var init_profile_limits = __esm(() => {
 });
 
 // src/lib/selection-cache.ts
-import { createHash as createHash8, randomUUID } from "crypto";
+import { createHash as createHash9, randomUUID } from "crypto";
 import { spawnSync as spawnSync2 } from "child_process";
 import { closeSync as closeSync7, constants as constants4, fstatSync as fstatSync7, fsyncSync, linkSync, lstatSync as lstatSync9, mkdirSync as mkdirSync3, openSync as openSync7, readFileSync as readFileSync10, readlinkSync as readlinkSync2, readSync as readSync4, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { hostname as hostname3 } from "os";
-import { dirname as dirname9, join as join15, parse as parse9, resolve as resolve8 } from "path";
+import { dirname as dirname10, join as join15, parse as parse9, resolve as resolve9 } from "path";
 import { isDeepStrictEqual } from "util";
 function selectionCacheRoot(options = {}) {
-  return resolve8(options.cacheDir ?? join15(getDataDirReadOnly(), "selection-cache"));
+  return resolve9(options.cacheDir ?? join15(getDataDirReadOnly(), "selection-cache"));
 }
 function selectionKey(selection) {
   validateSelection(selection);
   return hash2([selection.authority, selection.workspaceId, selection.slug, selection.version, selection.bundleDigest]);
 }
 function hash2(value) {
-  return createHash8("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash9("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function validateSelection(selection) {
   if (!selection || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(selection.slug) || !isValidSkillVersion(selection.version) || !/^sha256:[a-f0-9]{64}$/.test(selection.bundleDigest) || typeof selection.workspaceId !== "string" || !selection.workspaceId.trim() || selection.authorizationEpoch !== undefined && (typeof selection.authorizationEpoch !== "string" || !/^[a-f0-9]{32}$/.test(selection.authorizationEpoch)) || typeof selection.profileRevision !== "string" || !selection.profileRevision.trim()) {
@@ -46826,7 +47057,7 @@ function selectionBundlePath(selection, options = {}) {
   return join15(selectionCacheRoot(options), "objects", hash2(selection.authority), hash2(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
 }
 function assertRegularPath(path, createParents = false) {
-  const absolute = resolve8(path);
+  const absolute = resolve9(path);
   const root = parse9(absolute).root;
   let cursor = root;
   const segments = absolute.slice(root.length).split("/");
@@ -46883,7 +47114,7 @@ function writeSelectionJson(path, value) {
 }
 function atomicWrite(path, bytes, mode, durable = false) {
   assertRegularPath(path, true);
-  const temporary = join15(dirname9(path), `.selection-${randomUUID()}.tmp`);
+  const temporary = join15(dirname10(path), `.selection-${randomUUID()}.tmp`);
   try {
     const fd = openSync7(temporary, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, mode);
     try {
@@ -46895,7 +47126,7 @@ function atomicWrite(path, bytes, mode, durable = false) {
     }
     renameSync(temporary, path);
     if (durable)
-      syncDirectory(dirname9(path));
+      syncDirectory(dirname10(path));
   } finally {
     try {
       unlinkSync(temporary);
@@ -46905,8 +47136,8 @@ function atomicWrite(path, bytes, mode, durable = false) {
     }
   }
 }
-function readSelectionJson(path) {
-  const bytes = readRegularFile(path, MAX_PROFILE_DOCUMENT_BYTES);
+function readSelectionJson(path, maximumBytes = MAX_PROFILE_DOCUMENT_BYTES) {
+  const bytes = readRegularFile(path, Math.min(maximumBytes, MAX_PROFILE_DOCUMENT_BYTES));
   if (!bytes)
     return null;
   try {
@@ -46918,10 +47149,10 @@ function readSelectionJson(path) {
 async function verifiedEntries(selection, bytes, signal, deadline) {
   if (`sha256:${sha256Hex(bytes)}` !== selection.bundleDigest)
     throw new SkillSelectionError("BUNDLE_DIGEST_MISMATCH", "The skill bundle does not match its selected digest.");
-  const remaining = deadline === undefined ? undefined : Math.floor(deadline - performance.now());
+  const remaining = deadline === undefined ? undefined : Math.ceil(deadline - performance.now());
   signal?.throwIfAborted();
   if (remaining !== undefined && remaining <= 0)
-    throw new SkillSelectionError("SKILLS_API_UNAVAILABLE", "Skills session authorization deadline exceeded.");
+    throw new SkillBundleInspectionError("BUNDLE_TIMEOUT", "Bundle inspection deadline exceeded");
   const bundle = await inspectSkillBundle(bytes, { signal, ...remaining === undefined ? {} : { limits: { timeoutMs: remaining } } });
   return bundle.entries;
 }
@@ -47021,7 +47252,7 @@ function assertFreshCachedProfile(receipt, options = {}) {
   }
 }
 function projectSelectionLockPath(projectDir) {
-  return join15(resolve8(projectDir), ".skills", SELECTION_LOCK_FILE);
+  return join15(resolve9(projectDir), ".skills", SELECTION_LOCK_FILE);
 }
 function readProjectSelection(projectDir) {
   const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
@@ -47172,13 +47403,13 @@ function publishSessionLock(path, marker) {
     fsyncSync(fd);
     linkSync(stagingPath, path);
     published = true;
-    syncDirectory(dirname9(path));
+    syncDirectory(dirname10(path));
     const staged = lstatSync9(stagingPath);
     if (!staged.isFile() || staged.dev !== stat.dev || staged.ino !== stat.ino) {
       throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The initialized lock staging inode changed before publication completed.");
     }
     unlinkSync(stagingPath);
-    syncDirectory(dirname9(path));
+    syncDirectory(dirname10(path));
     handedOff = true;
     return { path, stagingPath, fd, dev: stat.dev, ino: stat.ino };
   } finally {
@@ -47223,14 +47454,14 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     writeFileSync3(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
 `);
     fsyncSync(guardFd);
-    const cacheOptions = { cacheDir: dirname9(dirname9(lock.path)) };
+    const cacheOptions = { cacheDir: dirname10(dirname10(lock.path)) };
     const current = readSessionLock(lock.marker.sessionId, cacheOptions);
     if (!current || current.dev !== lock.dev || current.ino !== lock.ino || current.sha256 !== lock.sha256 || current.mtimeMs !== lock.mtimeMs || !writerIsGone(current, explicitLocalHost))
       return null;
     const currentReceipt = readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions);
     if (currentReceipt?.sha256 !== receipt?.sha256 || currentReceipt?.generation !== receipt?.generation)
       return null;
-    const directory = join15(dirname9(dirname9(lock.path)), "session-lock-recoveries", randomUUID());
+    const directory = join15(dirname10(dirname10(lock.path)), "session-lock-recoveries", randomUUID());
     const archivePath = join15(directory, "original.write-lock");
     const recordPath = join15(directory, "recovery.json");
     assertRegularPath(archivePath, true);
@@ -47247,7 +47478,7 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     })}
 `));
     syncDirectory(directory);
-    syncDirectory(dirname9(directory));
+    syncDirectory(dirname10(directory));
     const finalLock = readSessionLock(lock.marker.sessionId, cacheOptions);
     if (!finalLock || finalLock.dev !== lock.dev || finalLock.ino !== lock.ino || finalLock.sha256 !== lock.sha256 || readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions)?.sha256 !== receipt?.sha256)
       return null;
@@ -47262,7 +47493,7 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
         archivedPaths.push(publicationPath);
       }
       syncDirectory(directory);
-      syncDirectory(dirname9(lock.path));
+      syncDirectory(dirname10(lock.path));
       for (const path of archivedPaths) {
         const before = lstatSync9(path, { throwIfNoEntry: false });
         const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
@@ -47413,8 +47644,8 @@ var init_selection_cache = __esm(() => {
   init_profile_limits();
   SkillSelectionError = class SkillSelectionError extends Error {
     code;
-    constructor(code, message) {
-      super(message);
+    constructor(code, message, options) {
+      super(message, options);
       this.code = code;
       this.name = "SkillSelectionError";
     }
@@ -47431,7 +47662,7 @@ __export(exports_remote_files, {
   decodeRemoteFiles: () => decodeRemoteFiles,
   MAX_REMOTE_FILE_BYTES: () => MAX_REMOTE_FILE_BYTES
 });
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 function describeRemoteFiles(files) {
   if (files.length > 10)
     throw new Error("At most 10 input files are supported");
@@ -47448,7 +47679,7 @@ function describeRemoteFiles(files) {
   });
 }
 function sha256(bytes) {
-  return createHash9("sha256").update(bytes).digest("hex");
+  return createHash10("sha256").update(bytes).digest("hex");
 }
 async function readBoundedResponse(response, maximum, signal) {
   if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > MAX_REMOTE_FILE_BYTES)
@@ -47524,6 +47755,10 @@ function identifier(value) {
 function invalid() {
   throw new Error("The Skills API returned an invalid profile response");
 }
+function unavailable(error61, message) {
+  const name = error61?.name;
+  return new SkillSelectionError("SKILLS_API_UNAVAILABLE", message, name === "AbortError" || name === "TimeoutError" ? { cause: new DOMException("The Skills API request was cut short", name) } : undefined);
+}
 function validateSelection2(value) {
   if (!object6(value) || !identifier(value.slug) || typeof value.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(value.version) || value.version.includes("..") || typeof value.bundleDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.bundleDigest))
     invalid();
@@ -47571,8 +47806,8 @@ class HttpProfileClient {
           ...init.headers
         }
       });
-    } catch {
-      throw new SkillSelectionError("SKILLS_API_UNAVAILABLE", "Unable to reach the configured Skills API");
+    } catch (error61) {
+      throw unavailable(error61, "Unable to reach the configured Skills API");
     }
     if (!response.ok) {
       response.body?.cancel().catch(() => {});
@@ -47589,7 +47824,9 @@ class HttpProfileClient {
   async read(response, limit = MAX_PROFILE_DOCUMENT_BYTES) {
     try {
       return JSON.parse(new TextDecoder().decode(await readBoundedResponse(response, limit, this.signal)));
-    } catch {
+    } catch (error61) {
+      if (this.signal?.aborted)
+        throw unavailable(this.signal.reason ?? error61, "The Skills API response was cut short");
       invalid();
     }
   }
@@ -47679,17 +47916,17 @@ var init_profile_client = __esm(() => {
 });
 
 // src/lib/preparation-process.ts
-function capturePreparationProcess(child, platform = process.platform, signalGroup = (pid, signal) => process.kill(pid, signal)) {
+function capturePreparationProcess(child2, platform = process.platform, signalGroup = (pid, signal) => process.kill(pid, signal)) {
   let spawnedPid;
   try {
-    spawnedPid = child.pid;
+    spawnedPid = child2.pid;
   } catch {}
   const groupId = typeof spawnedPid === "number" && Number.isSafeInteger(spawnedPid) && spawnedPid > 1 ? spawnedPid : undefined;
   const canSignalGroup = platform !== "win32" && groupId !== undefined;
   const killLiveChild = () => {
-    if (child.exitCode === null && child.signalCode === null) {
+    if (child2.exitCode === null && child2.signalCode === null) {
       try {
-        child.kill("SIGKILL");
+        child2.kill("SIGKILL");
       } catch {}
     }
   };
@@ -47952,28 +48189,6 @@ function isCodexLocalStdioMcpServer(name, server) {
   }
 }
 
-// src/lib/codex-native-compatibility.ts
-function supportsCodexNativeCapability(version2, capability) {
-  return typeof version2 === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version2) && MEASURED_CODEX_CAPABILITIES[version2].includes(capability);
-}
-var MEASURED_CODEX_CAPABILITIES, SUPPORTED_CODEX_HOOK_VERSIONS;
-var init_codex_native_compatibility = __esm(() => {
-  MEASURED_CODEX_CAPABILITIES = {
-    "codex-cli 0.153.0": ["hooks"],
-    "codex-cli 0.154.0": ["hooks"],
-    "codex-cli 0.155.0": ["hooks"],
-    "codex-cli 0.155.1": ["hooks"],
-    "codex-cli 0.156.1": ["hooks"],
-    "codex-cli 0.157.0": ["hooks"],
-    "codex-cli 0.157.1": ["hooks"],
-    "codex-cli 0.158.0": ["hooks"],
-    "codex-cli 0.159.0": ["hooks"],
-    "codex-cli 0.159.2": ["hooks", "qualified-skill-catalog"],
-    "codex-cli 0.160.0": ["hooks", "qualified-skill-catalog"]
-  };
-  SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version2) => supportsCodexNativeCapability(version2, "hooks")));
-});
-
 // src/lib/codex-hook-rpc.ts
 var init_codex_hook_rpc = __esm(() => {
   init_codex_corpus_write();
@@ -47994,7 +48209,7 @@ var init_codex_native_skill_catalog = __esm(() => {
 });
 
 // src/lib/codex-plugin-skill-controls.ts
-import { basename as basename5, dirname as dirname10, join as join17, relative as relative4, resolve as resolve9, sep as sep5 } from "path";
+import { basename as basename6, dirname as dirname11, join as join17, relative as relative4, resolve as resolve10, sep as sep5 } from "path";
 import { lstatSync as lstatSync11, readdirSync as readdirSync6, readlinkSync as readlinkSync3, realpathSync as realpathSync3 } from "fs";
 function refuse() {
   throw new Error("CODEX_NATIVE_SKILL_IDENTITY_UNSUPPORTED: review native plugin names and hook controls");
@@ -48058,7 +48273,7 @@ function mcpControls(path, read) {
 function isBundledCleanupHooks(root, namespace, value) {
   const object7 = (v) => Boolean(v && typeof v === "object" && !Array.isArray(v));
   const exactKeys = (v, keys) => Object.keys(v).length === keys.length && keys.every((key) => Object.hasOwn(v, key));
-  if (basename5(dirname10(root)) !== namespace || basename5(dirname10(dirname10(root))) !== "openai-bundled")
+  if (basename6(dirname11(root)) !== namespace || basename6(dirname11(dirname11(root))) !== "openai-bundled")
     return false;
   const server = namespace === "unified-computer-use" ? "cua_repl" : ["browser", "chrome", "chrome-dev", "chrome-internal", "computer-use"].includes(namespace) ? "node_repl" : undefined;
   if (!server || !object7(value) || !exactKeys(value, ["hooks"]) || !object7(value.hooks))
@@ -48092,7 +48307,7 @@ function rootControls(root, read) {
   }
   if (!manifest || typeof manifest !== "object" || Array.isArray(manifest) || !identifier2(manifest.name))
     refuse();
-  const cacheVersion = basename5(root), declaredVersion = manifest.version === undefined ? "" : typeof manifest.version === "string" ? manifest.version.trim() : null;
+  const cacheVersion = basename6(root), declaredVersion = manifest.version === undefined ? "" : typeof manifest.version === "string" ? manifest.version.trim() : null;
   if (declaredVersion === null || (declaredVersion ? declaredVersion !== cacheVersion : cacheVersion !== CODEX_DEFAULT_AGENT_PLUGIN_VERSION))
     refuse();
   if (manifest.hooks !== undefined && !isBundledCleanupHooks(root, manifest.name, manifest.hooks) || manifest.commands !== undefined || manifest.mcpServers !== undefined && manifest.mcpServers !== "./.mcp.json" || manifest.apps !== undefined && manifest.apps !== "./.app.json" || lstatSync11(join17(root, "hooks"), { throwIfNoEntry: false }))
@@ -48116,13 +48331,13 @@ function rootControls(root, read) {
 function reviewedDisabledCodexPluginParent(cache, parent, controls, rules) {
   try {
     const parts = relative4(cache, parent).split(sep5), enrolled = controls.filter((control) => control.pluginParent === parent);
-    if (resolve9(parent) !== parent || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !enrolled.length || !Array.isArray(rules))
+    if (resolve10(parent) !== parent || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !enrolled.length || !Array.isArray(rules))
       return false;
-    for (let cursor = parent;; cursor = dirname10(cursor)) {
+    for (let cursor = parent;; cursor = dirname11(cursor)) {
       const stat = lstatSync11(cursor, { throwIfNoEntry: false });
       if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
         return false;
-      if (dirname10(cursor) === cursor)
+      if (dirname11(cursor) === cursor)
         break;
     }
     return enrolled.every((control) => control.namespace === parts[1] && control.pluginId === `${parts[1]}@${parts[0]}` && remotePluginIdentifier(control.remotePluginId) && control.skillsOnly === true && !control.appSha256 && !control.mcpSha256 && control.name.startsWith(control.namespace + ":") && /^[a-f0-9]{64}$/.test(control.manifestSha256) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === control.name && rule.enabled === false) && !rules.some((rule) => (typeof rule?.name === "string" && rule.name.trim() === control.name || typeof rule?.path === "string" && (rule.path === parent || rule.path.startsWith(parent + sep5))) && rule.enabled !== false));
@@ -48135,14 +48350,14 @@ function absentDisabledCodexPluginParent(cache, parent, controls, rules) {
 }
 function reviewedRetiredCodexRoot(cache, root, controls, rules, read, allowAbsent = false) {
   try {
-    const parent = dirname10(root), parts = relative4(cache, parent).split(sep5), enrolled = controls.filter((control) => control.pluginParent === parent);
-    if (resolve9(root) !== root || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !basename5(root) || basename5(root) === "latest" || !enrolled.length || !Array.isArray(rules))
+    const parent = dirname11(root), parts = relative4(cache, parent).split(sep5), enrolled = controls.filter((control) => control.pluginParent === parent);
+    if (resolve10(root) !== root || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !basename6(root) || basename6(root) === "latest" || !enrolled.length || !Array.isArray(rules))
       return false;
-    for (let cursor = root;; cursor = dirname10(cursor)) {
+    for (let cursor = root;; cursor = dirname11(cursor)) {
       const stat = lstatSync11(cursor, { throwIfNoEntry: false });
       if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
         return false;
-      if (dirname10(cursor) === cursor)
+      if (dirname11(cursor) === cursor)
         break;
     }
     if (!enrolled.every((control) => control.namespace === parts[1] && control.pluginId === `${parts[1]}@${parts[0]}` && remotePluginIdentifier(control.remotePluginId) && control.skillsOnly === true && !control.appSha256 && !control.mcpSha256 && control.name.startsWith(control.namespace + ":") && /^[a-f0-9]{64}$/.test(control.manifestSha256) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === control.name && rule.enabled === false) && !rules.some((rule) => (typeof rule?.name === "string" && rule.name.trim() === control.name || typeof rule?.path === "string" && (rule.path === parent || rule.path === root || rule.path.startsWith(root + sep5))) && rule.enabled !== false)))
@@ -48189,8 +48404,8 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
       for (const name of names) {
         let root = join17(parent, name), stat = lstatSync11(root);
         if (stat.isSymbolicLink()) {
-          const target = resolve9(parent, readlinkSync3(root));
-          if (name !== "latest" || dirname10(target) !== parent || !lstatSync11(target).isDirectory() || realpathSync3(target) !== target)
+          const target = resolve10(parent, readlinkSync3(root));
+          if (name !== "latest" || dirname11(target) !== parent || !lstatSync11(target).isDirectory() || realpathSync3(target) !== target)
             return false;
           root = target;
           stat = lstatSync11(root);
@@ -48210,7 +48425,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
 function sourceInputUnchanged(input2, cache, read) {
   try {
     const parts = relative4(cache, input2.pluginParent).split(sep5);
-    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== input2.namespace || input2.pluginId !== `${parts[1]}@${parts[0]}` || !codexPluginSourceIsConfigControlled({ id: input2.pluginId, sourceType: "local", sourceSha256: input2.sourceSha256 }) || input2.sourceSha256 !== hashNativeJsonControls(JSON.stringify({ type: "local", path: input2.sourceRoot })) || resolve9(input2.sourceRoot) !== input2.sourceRoot || !lstatSync11(input2.sourceRoot).isDirectory() || realpathSync3(input2.sourceRoot) !== input2.sourceRoot || input2.sourceRoot === cache || input2.sourceRoot.startsWith(cache + sep5) || cache.startsWith(input2.sourceRoot + sep5))
+    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== input2.namespace || input2.pluginId !== `${parts[1]}@${parts[0]}` || !codexPluginSourceIsConfigControlled({ id: input2.pluginId, sourceType: "local", sourceSha256: input2.sourceSha256 }) || input2.sourceSha256 !== hashNativeJsonControls(JSON.stringify({ type: "local", path: input2.sourceRoot })) || resolve10(input2.sourceRoot) !== input2.sourceRoot || !lstatSync11(input2.sourceRoot).isDirectory() || realpathSync3(input2.sourceRoot) !== input2.sourceRoot || input2.sourceRoot === cache || input2.sourceRoot.startsWith(cache + sep5) || cache.startsWith(input2.sourceRoot + sep5))
       return false;
     const path = join17(input2.sourceRoot, ".codex-plugin/plugin.json"), stat = lstatSync11(path);
     if (!stat.isFile() || stat.size > 1024 * 1024 || realpathSync3(path) !== path)
@@ -48248,8 +48463,8 @@ var init_codex_native_skill_policy = __esm(() => {
 });
 
 // src/lib/codex-settings-witness-v1.ts
-import { createHash as createHash10 } from "crypto";
-function need3(value) {
+import { createHash as createHash11 } from "crypto";
+function need4(value) {
   if (!value)
     throw new Error("Invalid Codex settings witness");
 }
@@ -48264,14 +48479,14 @@ function numericTokens(text2) {
       continue;
     }
     if (char === '"' || char === "'") {
-      const quote = char, triple = text2.slice(at, at + 3) === quote.repeat(3);
+      const quote2 = char, triple = text2.slice(at, at + 3) === quote2.repeat(3);
       at += triple ? 3 : 1;
       while (at < text2.length) {
-        if (quote === '"' && text2[at] === "\\") {
+        if (quote2 === '"' && text2[at] === "\\") {
           at += 2;
           continue;
         }
-        if (text2.slice(at, at + (triple ? 3 : 1)) === quote.repeat(triple ? 3 : 1)) {
+        if (text2.slice(at, at + (triple ? 3 : 1)) === quote2.repeat(triple ? 3 : 1)) {
           at += triple ? 3 : 1;
           break;
         }
@@ -48292,8 +48507,8 @@ function numericTokens(text2) {
   }
   return result;
 }
-function canonical4(value, depth = 0, budget2 = { remaining: 65536 }) {
-  need3(depth <= 32 && --budget2.remaining >= 0);
+function canonical5(value, depth = 0, budget2 = { remaining: 65536 }) {
+  need4(depth <= 32 && --budget2.remaining >= 0);
   if (value === null)
     return ["null"];
   if (typeof value === "string")
@@ -48301,20 +48516,20 @@ function canonical4(value, depth = 0, budget2 = { remaining: 65536 }) {
   if (typeof value === "boolean")
     return ["boolean", value];
   if (typeof value === "number") {
-    need3(Number.isFinite(value));
+    need4(Number.isFinite(value));
     return ["number", String(value)];
   }
   if (value instanceof Date) {
-    need3(Number.isFinite(value.getTime()));
+    need4(Number.isFinite(value.getTime()));
     return ["date", value.toISOString()];
   }
   if (Array.isArray(value))
-    return ["array", value.map((child) => canonical4(child, depth + 1, budget2))];
-  need3(value && typeof value === "object");
-  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, canonical4(child, depth + 1, budget2)])];
+    return ["array", value.map((child2) => canonical5(child2, depth + 1, budget2))];
+  need4(value && typeof value === "object");
+  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child2]) => [key, canonical5(child2, depth + 1, budget2)])];
 }
 function hashCodexSettingsReplacement(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
-  need3(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
   budget2.remaining -= Buffer.byteLength(text2);
   let config2;
   try {
@@ -48322,23 +48537,23 @@ function hashCodexSettingsReplacement(text2, budget2 = { remaining: 256 * 1024 *
   } catch {
     throw new Error("Invalid Codex settings witness");
   }
-  need3(config2 && typeof config2 === "object" && !Array.isArray(config2));
+  need4(config2 && typeof config2 === "object" && !Array.isArray(config2));
   if (Object.hasOwn(config2, "model")) {
-    need3(typeof config2.model === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(config2.model));
+    need4(typeof config2.model === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(config2.model));
     delete config2.model;
   }
   for (const [key, values] of [["model_reasoning_effort", EFFORT], ["model_verbosity", VERBOSITY]])
     if (Object.hasOwn(config2, key)) {
-      need3(typeof config2[key] === "string" && values.has(config2[key]));
+      need4(typeof config2[key] === "string" && values.has(config2[key]));
       delete config2[key];
     }
-  return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical4(config2), numericTokens(text2)])}`);
+  return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical5(config2), numericTokens(text2)])}`);
 }
 function captureCodexSettings(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const text2 = readNativeSettingsWitnessFile(path, budget2, "config.toml");
   return { path, hashMode: "codex-settings-v1", sha256: hashCodexSettingsReplacement(text2) };
 }
-var sha = (text2) => createHash10("sha256").update(text2).digest("hex"), EFFORT, VERBOSITY;
+var sha = (text2) => createHash11("sha256").update(text2).digest("hex"), EFFORT, VERBOSITY;
 var init_codex_settings_witness_v1 = __esm(() => {
   init_claude_settings_witness();
   EFFORT = new Set(["none", "minimal", "low", "medium", "high", "xhigh"]);
@@ -48411,9 +48626,9 @@ function projectRegularCodexMcp(config2, source) {
 var init_codex_mcp_discovery_projection = () => {};
 
 // src/lib/codex-settings-witness.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
-function need4(value) {
+function need5(value) {
   if (!value)
     throw new Error("Invalid Codex settings witness");
 }
@@ -48434,14 +48649,14 @@ function numericTokens2(text2) {
       continue;
     }
     if (char === '"' || char === "'") {
-      const quote = char, triple = text2.slice(at, at + 3) === quote.repeat(3);
+      const quote2 = char, triple = text2.slice(at, at + 3) === quote2.repeat(3);
       at += triple ? 3 : 1;
       while (at < text2.length) {
-        if (quote === '"' && text2[at] === "\\") {
+        if (quote2 === '"' && text2[at] === "\\") {
           at += 2;
           continue;
         }
-        if (text2.slice(at, at + (triple ? 3 : 1)) === quote.repeat(triple ? 3 : 1)) {
+        if (text2.slice(at, at + (triple ? 3 : 1)) === quote2.repeat(triple ? 3 : 1)) {
           at += triple ? 3 : 1;
           break;
         }
@@ -48462,8 +48677,8 @@ function numericTokens2(text2) {
   }
   return result.sort();
 }
-function canonical5(value, depth = 0, budget2 = { remaining: 65536 }) {
-  need4(depth <= 32 && --budget2.remaining >= 0);
+function canonical6(value, depth = 0, budget2 = { remaining: 65536 }) {
+  need5(depth <= 32 && --budget2.remaining >= 0);
   if (value === null)
     return ["null"];
   if (typeof value === "string")
@@ -48471,17 +48686,17 @@ function canonical5(value, depth = 0, budget2 = { remaining: 65536 }) {
   if (typeof value === "boolean")
     return ["boolean", value];
   if (typeof value === "number") {
-    need4(Number.isFinite(value));
+    need5(Number.isFinite(value));
     return ["number", String(value)];
   }
   if (isDate(value)) {
-    need4(Number.isFinite(value.getTime()));
+    need5(Number.isFinite(value.getTime()));
     return ["date", value.toISOString()];
   }
   if (Array.isArray(value))
-    return ["array", value.map((child) => canonical5(child, depth + 1, budget2))];
-  need4(isRecord3(value));
-  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, canonical5(child, depth + 1, budget2)])];
+    return ["array", value.map((child2) => canonical6(child2, depth + 1, budget2))];
+  need5(isRecord3(value));
+  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child2]) => [key, canonical6(child2, depth + 1, budget2)])];
 }
 function normalize2(config2, version2 = 2) {
   if (isRecord3(config2.hooks)) {
@@ -48523,15 +48738,15 @@ function inference(target, version2) {
     if (Object.hasOwn(target, key)) {
       const value = target[key];
       if (key === "model")
-        need4(typeof value === "string" && MODEL.test(value));
+        need5(typeof value === "string" && MODEL.test(value));
       else if (key === "personality")
-        need4(typeof value === "string" && ["none", "friendly", "pragmatic"].includes(value));
+        need5(typeof value === "string" && ["none", "friendly", "pragmatic"].includes(value));
       else if (version2 >= 3 && key !== "model_verbosity") {
-        need4(typeof value === "string" && value.length <= 128 && !/[\x00-\x1f\x7f]/.test(value));
+        need5(typeof value === "string" && value.length <= 128 && !/[\x00-\x1f\x7f]/.test(value));
         if (key !== "service_tier")
-          need4(value.length > 0);
+          need5(value.length > 0);
       } else
-        need4(typeof value === "string" && (key === "model_reasoning_effort" ? EFFORT2.has(value) : VERBOSITY2.has(value)));
+        need5(typeof value === "string" && (key === "model_reasoning_effort" ? EFFORT2.has(value) : VERBOSITY2.has(value)));
       delete target[key];
     }
 }
@@ -48564,14 +48779,14 @@ function projectModelAvailabilityNux(config2, text2) {
         continue;
       }
       if (char === '"' || char === "'") {
-        const quote = char;
+        const quote2 = char;
         at++;
         while (at < span.length) {
-          if (quote === '"' && span[at] === "\\") {
+          if (quote2 === '"' && span[at] === "\\") {
             at += 2;
             continue;
           }
-          if (span[at++] === quote)
+          if (span[at++] === quote2)
             break;
         }
         continue;
@@ -48651,14 +48866,14 @@ function settingsDigest2(text2, version2 = 2) {
   } catch {
     throw new Error("Invalid Codex settings witness");
   }
-  need4(isRecord3(config2));
+  need5(isRecord3(config2));
   const mcp = version2 >= 3 ? projectRegularCodexMcp(config2, text2) : { config: config2, numericSource: text2 };
   const projected = version2 === 4 ? projectModelAvailabilityNux(mcp.config, mcp.numericSource) : mcp;
   normalize2(projected.config, version2);
-  return sha2(`hasna.skills.codex-settings.v${version2}\x00${JSON.stringify([canonical5(projected.config), numericTokens2(projected.numericSource)])}`);
+  return sha2(`hasna.skills.codex-settings.v${version2}\x00${JSON.stringify([canonical6(projected.config), numericTokens2(projected.numericSource)])}`);
 }
 function hashCodexSettingsReplacementV2(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
-  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  need5(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
   budget2.remaining -= Buffer.byteLength(text2);
   return settingsDigest2(text2);
 }
@@ -48667,7 +48882,7 @@ function captureCodexSettingsV2(path, budget2 = { remaining: 256 * 1024 * 1024 }
   return { path, hashMode: "codex-settings-v2", sha256: settingsDigest2(text2) };
 }
 function hashCodexSettingsReplacementV3(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
-  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  need5(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
   budget2.remaining -= Buffer.byteLength(text2);
   return settingsDigest2(text2, 3);
 }
@@ -48675,14 +48890,14 @@ function captureCodexSettingsV3(path, budget2 = { remaining: 256 * 1024 * 1024 }
   return { path, hashMode: "codex-settings-v3", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 3) };
 }
 function hashCodexSettingsReplacementV4(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
-  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  need5(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
   budget2.remaining -= Buffer.byteLength(text2);
   return settingsDigest2(text2, 4);
 }
 function captureCodexSettingsV4(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   return { path, hashMode: "codex-settings-v4", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 4) };
 }
-var sha2 = (text2) => createHash11("sha256").update(text2).digest("hex"), EFFORT2, VERBOSITY2, MODEL, CODEX_DISCOVERY_PROJECTION_FIELDS, INFERENCE;
+var sha2 = (text2) => createHash12("sha256").update(text2).digest("hex"), EFFORT2, VERBOSITY2, MODEL, CODEX_DISCOVERY_PROJECTION_FIELDS, INFERENCE;
 var init_codex_settings_witness = __esm(() => {
   init_codex_settings_witness_v1();
   init_codex_settings_witness_v1();
@@ -48698,8 +48913,8 @@ var init_codex_settings_witness = __esm(() => {
 // src/lib/managed-policy.ts
 import { closeSync as closeSync9, constants as constants6, fstatSync as fstatSync9, lstatSync as lstatSync12, openSync as openSync9, readSync as readSync5 } from "fs";
 import { join as join18 } from "path";
-function refusal(reason = "is unreadable") {
-  return new SkillSelectionError("INVALID_AGENT_POLICY", `The Skills agent loading policy ${reason}; refusing legacy fallback.`);
+function refusal(reason2 = "is unreadable") {
+  return new SkillSelectionError("INVALID_AGENT_POLICY", `The Skills agent loading policy ${reason2}; refusing legacy fallback.`);
 }
 function parseManagedSkillPolicy(text2) {
   if (Buffer.byteLength(text2) > AGENT_POLICY_LIMITS.bytes)
@@ -48775,7 +48990,7 @@ var init_managed_policy = __esm(() => {
 });
 
 // src/lib/agent-bridge.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 var CLI_BRIDGE_VERSION = 1, markdown = `---
 name: skills-cli
 description: Discover, load, author, and run versioned skills through the Skills CLI when a task needs reusable instructions or an executable skill.
@@ -48791,7 +49006,7 @@ Use the Skills CLI as the skill authority for this station.
 This bridge contains no skill payloads. Do not copy skill content into agent-native skill directories or load other native skill copies. If a Skills command refuses authority, selection, integrity, or native drift, report that refusal and use its repair guidance; do not substitute bundled or stale local content. Explicit local draft authoring remains available.
 `, CLI_BRIDGE_DIGEST, CLI_BRIDGE_FILES;
 var init_agent_bridge = __esm(() => {
-  CLI_BRIDGE_DIGEST = createHash12("sha256").update(markdown).digest("hex");
+  CLI_BRIDGE_DIGEST = createHash13("sha256").update(markdown).digest("hex");
   CLI_BRIDGE_FILES = Object.freeze({
     "SKILL.md": markdown,
     ".hasna-skills.json": `${JSON.stringify({ managedBy: "@hasna/skills", kind: "cli-bridge", version: CLI_BRIDGE_VERSION, protocol: "selection-v1", contentSha256: CLI_BRIDGE_DIGEST }, null, 2)}
@@ -48804,28 +49019,28 @@ var init_agent_codex = () => {};
 
 // src/lib/agent-sumi.ts
 import { existsSync as existsSync8, lstatSync as lstatSync13, realpathSync as realpathSync4 } from "fs";
-import { join as join19, resolve as resolve10 } from "path";
+import { join as join19, resolve as resolve11 } from "path";
 function sumiConfigDirectory(home, env = process.env) {
   for (const key of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
     if (env[key] !== undefined)
       throw new Error(`Sumi ${key} requires a dedicated discovery adapter; unset it before Skills integration`);
   const selected = (key) => env[key]?.trim() ? env[key] : undefined;
-  const expand = (value) => resolve10(value === "~" ? home : value.startsWith("~/") ? join19(home, value.slice(2)) : value);
+  const expand = (value) => resolve11(value === "~" ? home : value.startsWith("~/") ? join19(home, value.slice(2)) : value);
   const explicit = selected("SUMI_CONFIG_DIR");
   const xdg = selected("XDG_CONFIG_HOME");
   const custom2 = selected("SUMI_HOME");
-  const canonical6 = explicit ? expand(explicit) : xdg ? join19(expand(xdg), "sumi") : join19(custom2 ? expand(custom2) : join19(home, ".hasna-internal/sumi"), "config");
+  const canonical7 = explicit ? expand(explicit) : xdg ? join19(expand(xdg), "sumi") : join19(custom2 ? expand(custom2) : join19(home, ".hasna-internal/sumi"), "config");
   if (explicit || xdg || custom2)
-    return canonical6;
+    return canonical7;
   const legacy = join19(home, ".config/sumi");
-  const a = lstatSync13(canonical6, { throwIfNoEntry: false }), b = lstatSync13(legacy, { throwIfNoEntry: false });
-  if (a && b && realpathSync4(canonical6) !== realpathSync4(legacy))
+  const a = lstatSync13(canonical7, { throwIfNoEntry: false }), b = lstatSync13(legacy, { throwIfNoEntry: false });
+  if (a && b && realpathSync4(canonical7) !== realpathSync4(legacy))
     throw new Error("Sumi config roots conflict; complete native home adoption before Skills integration");
-  const path = a ? canonical6 : b ? legacy : canonical6;
+  const path = a ? canonical7 : b ? legacy : canonical7;
   if (!existsSync8(path))
     return path;
   const physical = realpathSync4(path);
-  if ((a?.isSymbolicLink() || b?.isSymbolicLink()) && ![canonical6, legacy].includes(physical))
+  if ((a?.isSymbolicLink() || b?.isSymbolicLink()) && ![canonical7, legacy].includes(physical))
     throw new Error("Sumi config alias must resolve to its canonical or legacy root");
   return physical;
 }
@@ -48835,19 +49050,22 @@ function sumiConfigPath(home) {
 var init_agent_sumi = () => {};
 
 // src/lib/codex-hook-trust-files.ts
-import { closeSync as closeSync10, constants as constants7, fstatSync as fstatSync10, fsyncSync as fsyncSync2, lstatSync as lstatSync14, openSync as openSync10, readSync as readSync6, writeFileSync as writeFileSync4 } from "fs";
-import { createHash as createHash13 } from "crypto";
-import { dirname as dirname11 } from "path";
-function need5(value, code) {
+import { closeSync as closeSync10, constants as constants7, fstatSync as fstatSync10, fsyncSync as fsyncSync2, lstatSync as lstatSync14, openSync as openSync10, readlinkSync as readlinkSync4, readSync as readSync6, writeFileSync as writeFileSync4 } from "fs";
+import { createHash as createHash14 } from "crypto";
+import { dirname as dirname12, isAbsolute as isAbsolute10, resolve as resolve12 } from "path";
+function need6(value, code) {
   if (!value)
     throw new Error(`CODEX_HOOK_TRUST_${code}`);
 }
+function trustedAncestorOwner(uid) {
+  return BigInt(uid) === 0n || BigInt(uid) === BigInt(process.getuid());
+}
 function safeParents(file2) {
-  for (let p = dirname11(file2);; p = dirname11(p)) {
+  for (let p = dirname12(file2);; p = dirname12(p)) {
     const s = lstatSync14(p);
-    need5(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
-    need5((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
-    if (dirname11(p) === p)
+    need6(s.isDirectory() && !s.isSymbolicLink() && trustedAncestorOwner(s.uid), "UNSAFE_PARENT");
+    need6((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
+    if (dirname12(p) === p)
       break;
   }
 }
@@ -48855,12 +49073,12 @@ function snapshot(file2, privateFile = false, options = {}) {
   const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
   safeParents(file2);
   const initial = lstatSync14(file2, { bigint: true });
-  need5(initial.isFile() && initial.uid === BigInt(process.getuid()) && (initial.nlink === 1n || readOnlyPackage && initial.nlink > 1n) && (initial.mode & 0o022n) === 0n && (!privateFile || (initial.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
-  need5(initial.size <= 8n * 1024n * 1024n, "FILE_BOUND");
+  need6(initial.isFile() && initial.uid === BigInt(process.getuid()) && (initial.nlink === 1n || readOnlyPackage && initial.nlink > 1n) && (initial.mode & 0o022n) === 0n && (!privateFile || (initial.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
+  need6(initial.size <= 8n * 1024n * 1024n, "FILE_BOUND");
   const fd = openSync10(file2, constants7.O_RDONLY | constants7.O_NOFOLLOW | constants7.O_NONBLOCK);
   try {
     const before = fstatSync10(fd, { bigint: true });
-    need5(sameStat(initial, before), "INPUT_CHANGED");
+    need6(sameStat(initial, before), "INPUT_CHANGED");
     const bytes = Buffer.alloc(Number(before.size) + 1);
     let length = 0;
     while (length < bytes.length) {
@@ -48869,16 +49087,16 @@ function snapshot(file2, privateFile = false, options = {}) {
         break;
       length += n2;
     }
-    need5(length === Number(before.size) && sameStat(before, fstatSync10(fd, { bigint: true })) && sameStat(before, lstatSync14(file2, { bigint: true })), "INPUT_CHANGED");
+    need6(length === Number(before.size) && sameStat(before, fstatSync10(fd, { bigint: true })) && sameStat(before, lstatSync14(file2, { bigint: true })), "INPUT_CHANGED");
     const content = bytes.subarray(0, length), text2 = new TextDecoder("utf-8", { fatal: true }).decode(content);
-    return { file: file2, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash13("sha256").update(content).digest("hex") };
+    return { file: file2, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash14("sha256").update(content).digest("hex") };
   } finally {
     closeSync10(fd);
   }
 }
 function unchanged2(before) {
   const after = snapshot(before.file, before.privateFile, before.readOnlyPackage ? { readOnlyPackage: true } : {});
-  need5(sameStat(before.stat, after.stat) && after.sha256 === before.sha256, "INPUT_CHANGED");
+  need6(sameStat(before.stat, after.stat) && after.sha256 === before.sha256, "INPUT_CHANGED");
 }
 var sameStat = (a, b) => ["dev", "ino", "uid", "nlink", "mode", "size", "mtimeNs", "ctimeNs"].every((key) => a[key] === b[key]);
 var init_codex_hook_trust_files = () => {};
@@ -49620,7 +49838,7 @@ var init_selection_resolver = __esm(() => {
 });
 
 // src/lib/plugin-projection.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function pluginRefusal(message) {
   throw new SkillSelectionError("PLUGIN_ADMISSION_REFUSED", message);
 }
@@ -49698,7 +49916,7 @@ function pluginFileWitnesses(entries) {
     return { path: item.path, mode: item.mode, size: item.bytes.byteLength, sha256: pluginHash(item.bytes) };
   });
 }
-var PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash14("sha256").update(bytes).digest("hex");
+var PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash15("sha256").update(bytes).digest("hex");
 var init_plugin_projection = __esm(() => {
   init_selection_cache();
   PLUGIN_PROJECTION_LIMITS = Object.freeze({ files: 1024, bytes: 64 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, metadataBytes: 512 * 1024, registrations: 64, history: 128 });
@@ -49706,7 +49924,7 @@ var init_plugin_projection = __esm(() => {
 
 // src/lib/plugin-projection-store.ts
 import { constants as constants8, closeSync as closeSync11, fchmodSync, fstatSync as fstatSync11, fsyncSync as fsyncSync3, linkSync as linkSync2, lstatSync as lstatSync15, mkdirSync as mkdirSync6, openSync as openSync11, opendirSync as opendirSync2, readSync as readSync7, renameSync as renameSync2, rmdirSync as rmdirSync2, rmSync as rmSync2, unlinkSync as unlinkSync3, writeSync as writeSync2 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute9, join as join23, parse as parse10, resolve as resolve11 } from "path";
+import { dirname as dirname13, isAbsolute as isAbsolute11, join as join23, parse as parse10, resolve as resolve13 } from "path";
 function stat(path) {
   try {
     return lstatSync15(path, { bigint: true });
@@ -49716,8 +49934,8 @@ function stat(path) {
     return pluginRefusal("Cannot inspect plugin filesystem entry");
   }
 }
-function canonical6(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute9(path) && resolve11(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+function canonical7(path) {
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute11(path) && resolve13(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -49727,8 +49945,8 @@ function same3(left, right, identityOnly = false) {
   pluginNeed(right && left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.uid === right.uid && left.gid === right.gid && (identityOnly || left.size === right.size && left.nlink === right.nlink && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs), "Plugin filesystem entry changed during access");
 }
 function ancestors(path, create = false) {
-  canonical6(path);
-  const result = [], parent = dirname12(path), filesystemRoot = parse10(parent).root;
+  canonical7(path);
+  const result = [], parent = dirname13(path), filesystemRoot = parse10(parent).root;
   let current = filesystemRoot;
   for (const segment of ["", ...parent.slice(filesystemRoot.length).split("/").filter(Boolean)]) {
     if (segment)
@@ -49954,7 +50172,7 @@ var init_selected_manifest = __esm(() => {
 });
 
 // src/lib/plugin-admission.ts
-import { isAbsolute as isAbsolute10, join as join24, resolve as resolve12 } from "path";
+import { isAbsolute as isAbsolute12, join as join24, resolve as resolve14 } from "path";
 function validatePluginTarget(value) {
   pluginKeys(value, ["schemaVersion", "pluginId", "registrations", "native", "resolver"]);
   pluginNeed(value.schemaVersion === 1, "Invalid plugin admission target");
@@ -49964,7 +50182,7 @@ function validatePluginTarget(value) {
   for (const registration of value.registrations) {
     pluginKeys(registration, ["scope", "projectPath"]);
     pluginNeed(registration.scope === "user" || registration.scope === "project", "Unsupported plugin registration scope");
-    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute10(registration.projectPath) && resolve12(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
+    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute12(registration.projectPath) && resolve14(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
     const key = JSON.stringify([registration.scope, registration.projectPath]);
     pluginNeed(!scopes.has(key), "Duplicate plugin registration scope");
     scopes.add(key);
@@ -49972,7 +50190,7 @@ function validatePluginTarget(value) {
   for (const key of ["native", "resolver"]) {
     pluginKeys(value[key], key === "native" ? ["version", "executable", "digest"] : ["executable", "digest"]);
     pluginText(value[key].executable);
-    pluginNeed(isAbsolute10(value[key].executable) && resolve12(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute12(value[key].executable) && resolve14(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
     pluginDigest(value[key].digest);
   }
   pluginNeed(["2.1.274", "2.1.276"].includes(value.native.version), "Plugin admission requires a certified Claude command-source runtime (2.1.274 or 2.1.276)");
@@ -50111,7 +50329,7 @@ function validatePlan(value) {
   pluginNeed(identityDigest(plan) === plan.planDigest, "Plugin receipt immutable identity changed");
 }
 function pluginResolverCommand(binding) {
-  return `${quote("/bin/sh")} -eu -c ${quote(resolverGuard)} plugin-resolver ${quote(binding.target.resolver.executable)} ${quote(binding.target.resolver.digest)} ${quote(bindingId(binding))}`;
+  return `${quote2("/bin/sh")} -eu -c ${quote2(resolverGuard)} plugin-resolver ${quote2(binding.target.resolver.executable)} ${quote2(binding.target.resolver.digest)} ${quote2(bindingId(binding))}`;
 }
 function pluginBindingPath(storeRoot, id) {
   pluginNeed(/^[a-f0-9]{64}$/.test(id), "Invalid plugin binding identifier");
@@ -50145,7 +50363,7 @@ function readPluginAdmissionReceipt(storeRoot, id, digest) {
   pluginNeed(Number.isFinite(Date.parse(receipt.admittedAt)), "Invalid plugin admission time");
   return receipt;
 }
-var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`, resolverGuard = 'exec 9<"$1"; actual=$(/usr/bin/sha256sum /proc/self/fd/9); actual=${actual%% *}; [ "sha256:$actual" = "$2" ]; exec /proc/self/fd/9 integration plugin resolve --binding "$3"';
+var quote2 = (value) => `'${value.replaceAll("'", "'\\''")}'`, resolverGuard = 'exec 9<"$1"; actual=$(/usr/bin/sha256sum /proc/self/fd/9); actual=${actual%% *}; [ "sha256:$actual" = "$2" ]; exec /proc/self/fd/9 integration plugin resolve --binding "$3"';
 var init_plugin_admission = __esm(() => {
   init_profile_client();
   init_skill_bundle();
@@ -50158,7 +50376,7 @@ var init_plugin_admission = __esm(() => {
 
 // src/lib/plugin-discovery.ts
 import { closeSync as closeSync12, constants as constants9, fstatSync as fstatSync12, lstatSync as lstatSync16, openSync as openSync12, opendirSync as opendirSync3, readSync as readSync8 } from "fs";
-import { basename as basename6, dirname as dirname13, isAbsolute as isAbsolute11, join as join25, resolve as resolve13 } from "path";
+import { basename as basename7, dirname as dirname14, isAbsolute as isAbsolute13, join as join25, resolve as resolve15 } from "path";
 function validateManagedPluginWitnesses(value) {
   pluginNeed(Array.isArray(value) && value.length > 0 && value.length <= PLUGIN_PROJECTION_LIMITS.registrations, "Invalid managed plugin witness collection");
   const seen = new Set;
@@ -50167,15 +50385,15 @@ function validateManagedPluginWitnesses(value) {
     pluginNeed(typeof item.bindingId === "string" && /^[a-f0-9]{64}$/.test(item.bindingId) && !seen.has(item.bindingId), "Invalid or duplicate managed plugin witness");
     seen.add(item.bindingId);
     pluginText(item.storeRoot);
-    pluginNeed(isAbsolute11(item.storeRoot) && resolve13(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute13(item.storeRoot) && resolve15(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute11(path) && resolve13(path) === path, "Invalid plugin registry path");
-  for (let at = path;; at = dirname13(at)) {
+  pluginNeed(isAbsolute13(path) && resolve15(path) === path, "Invalid plugin registry path");
+  for (let at = path;; at = dirname14(at)) {
     pluginNeed(!lstatSync16(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
-    if (at === dirname13(at))
+    if (at === dirname14(at))
       break;
   }
 }
@@ -50225,7 +50443,7 @@ function hashManagedPluginRegistry(path, managed) {
     seen.add(target.pluginId);
     const rows = plugins[target.pluginId];
     pluginNeed(Array.isArray(rows) && rows.length === target.registrations.length, "Managed plugin registration membership changed");
-    const [name, market] = target.pluginId.split("@"), cacheRoot = join25(dirname13(path), "cache", market, name);
+    const [name, market] = target.pluginId.split("@"), cacheRoot = join25(dirname14(path), "cache", market, name);
     const scopes = new Set, approvals = new Map, currentFiles = new Map;
     plugins[target.pluginId] = rows.map((row) => {
       pluginNeed(pluginObject(row), "Invalid managed plugin registration");
@@ -50241,7 +50459,7 @@ function hashManagedPluginRegistry(path, managed) {
       pluginNeed(/^(?:[A-Za-z0-9][A-Za-z0-9._+-]*-)?[a-f0-9]{12}$/.test(row.version) && row.installPath === join25(cacheRoot, row.version), "Managed plugin cache path or version is outside its registration");
       const approval = (producer) => {
         pluginText(producer);
-        const digest = `sha256:${basename6(producer)}`;
+        const digest = `sha256:${basename7(producer)}`;
         const receipt2 = readPluginAdmissionReceipt(witness.storeRoot, witness.bindingId, digest);
         pluginNeed(receipt2.materializedPath === producer, "Managed producer path is not an approved immutable projection");
         if (!verified.has(producer)) {
@@ -50305,37 +50523,37 @@ var init_plugin_discovery = __esm(() => {
 });
 
 // src/lib/claude-marketplace-registry.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { closeSync as closeSync13, constants as constants10, fstatSync as fstatSync13, lstatSync as lstatSync17, openSync as openSync13, readSync as readSync9 } from "fs";
-import { basename as basename7, dirname as dirname14, isAbsolute as isAbsolute12, resolve as resolve14 } from "path";
-function need6(value, reason) {
+import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute14, resolve as resolve16 } from "path";
+function need7(value, reason2) {
   if (!value)
-    throw new Error(`Claude marketplace registry ${reason}`);
+    throw new Error(`Claude marketplace registry ${reason2}`);
 }
 function absolutePath2(value) {
-  need6(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute12(value) && resolve14(value) === value, "requires a normalized absolute path");
+  need7(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute14(value) && resolve16(value) === value, "requires a normalized absolute path");
 }
 function parents2(path) {
   const result = [];
-  for (let at = dirname14(path);; at = dirname14(at)) {
+  for (let at = dirname15(path);; at = dirname15(at)) {
     const stat2 = lstatSync17(at, { bigint: true });
-    need6(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
+    need7(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
     result.push([at, stat2]);
-    if (at === dirname14(at))
+    if (at === dirname15(at))
       return result;
   }
 }
 function readRegistry2(path, budget2) {
   absolutePath2(path);
-  need6(basename7(path) === "known_marketplaces.json", "requires known_marketplaces.json");
-  need6(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
+  need7(basename8(path) === "known_marketplaces.json", "requires known_marketplaces.json");
+  need7(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
   const ancestors2 = parents2(path), initial = lstatSync17(path, { bigint: true });
-  need6(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
-  need6(initial.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
+  need7(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
+  need7(initial.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
   const fd = openSync13(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
     const opened = fstatSync13(fd, { bigint: true });
-    need6(opened.isFile() && sameFile2(initial, opened), "changed during open");
+    need7(opened.isFile() && sameFile2(initial, opened), "changed during open");
     const bytes = Buffer.alloc(Number(opened.size) + 1);
     let length = 0;
     while (length < bytes.length) {
@@ -50345,10 +50563,10 @@ function readRegistry2(path, budget2) {
       length += count;
     }
     const after = fstatSync13(fd, { bigint: true }), current = lstatSync17(path, { bigint: true });
-    need6(current.isFile() && sameFile2(opened, after) && sameFile2(after, current) && BigInt(length) === opened.size, "changed during read");
+    need7(current.isFile() && sameFile2(opened, after) && sameFile2(after, current) && BigInt(length) === opened.size, "changed during read");
     for (const [ancestor, before] of ancestors2) {
       const now = lstatSync17(ancestor, { bigint: true });
-      need6(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
+      need7(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
     }
     budget2.remaining -= length;
     try {
@@ -50368,7 +50586,7 @@ function parse11(text2) {
       at++;
   };
   function string5() {
-    need6(text2[at] === '"', "contains invalid JSON");
+    need7(text2[at] === '"', "contains invalid JSON");
     const start = at++;
     while (at < text2.length) {
       const character = text2[at++];
@@ -50379,7 +50597,7 @@ function parse11(text2) {
         } catch {
           throw new Error("Claude marketplace registry contains invalid JSON string");
         }
-        need6(value2.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.stringCharacters, "exceeds its string limit");
+        need7(value2.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.stringCharacters, "exceeds its string limit");
         return value2;
       }
       if (character === "\\")
@@ -50388,7 +50606,7 @@ function parse11(text2) {
     throw new Error("Claude marketplace registry contains an unterminated JSON string");
   }
   function value(depth) {
-    need6(depth <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.depth && ++nodes <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.nodes, "exceeds its nesting or node limit");
+    need7(depth <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.depth && ++nodes <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.nodes, "exceeds its nesting or node limit");
     space();
     const character = text2[at];
     if (character === '"')
@@ -50402,17 +50620,17 @@ function parse11(text2) {
           if (object7) {
             space();
             const key = string5();
-            need6(!keys.has(key), "contains a duplicate JSON key");
+            need7(!keys.has(key), "contains a duplicate JSON key");
             keys.add(key);
             space();
-            need6(text2[at++] === ":", "contains invalid JSON");
+            need7(text2[at++] === ":", "contains invalid JSON");
             entries.push([key, value(depth + 1)]);
           } else
             items.push(value(depth + 1));
           space();
           if (text2[at] === end)
             break;
-          need6(text2[at++] === ",", "contains invalid JSON");
+          need7(text2[at++] === ",", "contains invalid JSON");
         }
       at++;
       return object7 ? { kind: "object", entries } : { kind: "array", items };
@@ -50424,64 +50642,64 @@ function parse11(text2) {
       }
     numberPattern.lastIndex = at;
     const number5 = numberPattern.exec(text2);
-    need6(number5, "contains invalid JSON");
+    need7(number5, "contains invalid JSON");
     at += number5[0].length;
     return { kind: "number", value: number5[0] };
   }
   const root = value(0);
   space();
-  need6(at === text2.length && root.kind === "object", "requires a JSON object without trailing content");
-  need6(root.entries.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.rows, "exceeds its marketplace row limit");
+  need7(at === text2.length && root.kind === "object", "requires a JSON object without trailing content");
+  need7(root.entries.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.rows, "exceeds its marketplace row limit");
   return root;
 }
 function exactKeys(value, keys) {
   return value?.kind === "object" && value.entries.length === keys.length && value.entries.every(([key]) => keys.includes(key));
 }
 function textField(value) {
-  need6(value?.kind === "string" && value.value.length > 0 && !/[\x00-\x1f\x7f]/.test(value.value), "contains an invalid recognized field");
+  need7(value?.kind === "string" && value.value.length > 0 && !/[\x00-\x1f\x7f]/.test(value.value), "contains an invalid recognized field");
   return value.value;
 }
 function normalizeRow(row, version2 = 1) {
   if (!exactKeys(row, ["source", "installLocation", "lastUpdated"])) {
     if (version2 !== 2 || !exactKeys(row, ["source", "installLocation", "lastUpdated", "autoUpdate"]))
       return;
-    const autoUpdate = field(row, "autoUpdate");
-    need6(autoUpdate?.kind === "literal" && (autoUpdate.value === "true" || autoUpdate.value === "false"), "contains an invalid automatic-update preference");
+    const autoUpdate = field2(row, "autoUpdate");
+    need7(autoUpdate?.kind === "literal" && (autoUpdate.value === "true" || autoUpdate.value === "false"), "contains an invalid automatic-update preference");
   }
-  const source = field(row, "source");
+  const source = field2(row, "source");
   if (source?.kind !== "object")
     return;
-  const type = field(source, "source");
+  const type = field2(source, "source");
   if (type?.kind !== "string" || !["github", "directory"].includes(type.value))
     return;
   const location = type.value === "github" ? "repo" : "path";
   if (!exactKeys(source, ["source", location]))
     return;
-  const sourceLocation = textField(field(source, location));
+  const sourceLocation = textField(field2(source, location));
   if (type.value === "directory")
     absolutePath2(sourceLocation);
-  absolutePath2(textField(field(row, "installLocation")));
-  const updated = textField(field(row, "lastUpdated"));
-  need6(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(updated), "contains an invalid recognized update timestamp");
+  absolutePath2(textField(field2(row, "installLocation")));
+  const updated = textField(field2(row, "lastUpdated"));
+  need7(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(updated), "contains an invalid recognized update timestamp");
   const millis = Date.parse(updated);
-  need6(Number.isFinite(millis) && new Date(millis).toISOString() === updated, "contains an invalid recognized update timestamp");
+  need7(Number.isFinite(millis) && new Date(millis).toISOString() === updated, "contains an invalid recognized update timestamp");
   row.entries = row.entries.map(([key, value]) => [key, key === "lastUpdated" ? { kind: "validated-update-time" } : value]);
 }
 function captureClaudeMarketplaceRegistry(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const value = parse11(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row);
-  const sha2562 = createHash15("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2562 = createHash16("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
   return { path, hashMode: "claude-marketplace-registry", sha256: sha2562 };
 }
 function captureClaudeMarketplaceRegistryV2(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const value = parse11(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row, 2);
-  const sha2562 = createHash15("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2562 = createHash16("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
   return { path, hashMode: "claude-marketplace-registry-v2", sha256: sha2562 };
 }
-var CLAUDE_MARKETPLACE_REGISTRY_LIMITS, sameFile2 = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs, field = (object7, key) => object7.entries.find(([name]) => name === key)?.[1];
+var CLAUDE_MARKETPLACE_REGISTRY_LIMITS, sameFile2 = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs, field2 = (object7, key) => object7.entries.find(([name]) => name === key)?.[1];
 var init_claude_marketplace_registry = __esm(() => {
   CLAUDE_MARKETPLACE_REGISTRY_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
 });
@@ -50500,10 +50718,10 @@ var init_codex_hook_additions_review = __esm(() => {
 });
 
 // src/lib/codex-hook-discovery-recovery.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function assertCodexHookDiscoveryRecovery(binding, witness) {
   const proof = proofs2.get(witness);
-  need5(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha3(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  need6(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha3(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   unchanged2(proof.before);
   unchanged2(proof.current);
   proof.recheckAdditions();
@@ -50512,10 +50730,10 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
   if (!witness || source.path !== witness.configPath || source.hashMode !== "bytes")
     return false;
   assertCodexHookDiscoveryRecovery(binding, witness);
-  need5(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  need6(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   return true;
 }
-var sha3 = (text2) => createHash16("sha256").update(text2).digest("hex"), fields, proofs2;
+var sha3 = (text2) => createHash17("sha256").update(text2).digest("hex"), fields, proofs2;
 var init_codex_hook_discovery_recovery = __esm(() => {
   init_codex_hook_trust_files();
   init_codex_hook_trust_layout();
@@ -50526,10 +50744,18 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 });
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { lstatSync as lstatSync18, readFileSync as readFileSync15, readdirSync as readdirSync7, realpathSync as realpathSync5 } from "fs";
-import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute13, join as join26, resolve as resolve15, sep as sep6 } from "path";
+import { basename as basename9, dirname as dirname16, isAbsolute as isAbsolute15, join as join26, resolve as resolve17, sep as sep6 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
+function discoveryExecutable(agent) {
+  const command = DISCOVERY_RUNTIME_COMMANDS[agent];
+  const found = command ? Bun.which(command) : null;
+  if (!command || !found)
+    return null;
+  const path = resolve17(found), target = realpathOrNull(path);
+  return target === null ? null : { command, path, target };
+}
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -50541,12 +50767,12 @@ function parseConfig(text2, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute13(path) || path.includes("\x00"))
+  if (!isAbsolute15(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
-  for (let cursor = path;; cursor = dirname15(cursor)) {
+  for (let cursor = path;; cursor = dirname16(cursor)) {
     if (lstatSync18(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname15(cursor) === cursor)
+    if (dirname16(cursor) === cursor)
       break;
   }
 }
@@ -50565,7 +50791,7 @@ function projectNativeDiscoveryFields(text2, format, fields2, path) {
   const object7 = format === "yaml" ? parseHermesConfig(text2) : parseConfig(text2, path, format === "toml");
   if (!object7 || typeof object7 !== "object" || Array.isArray(object7))
     throw new Error("Expected native discovery configuration object");
-  return digest(JSON.stringify(Object.fromEntries(fields2.map((field2) => [field2, object7[field2] ?? null]))));
+  return digest(JSON.stringify(Object.fromEntries(fields2.map((field3) => [field3, object7[field3] ?? null]))));
 }
 function isSupersededSettingsProjection(agent, configPath, source) {
   if (agent === "sumi")
@@ -50610,6 +50836,14 @@ function projected(source, changes, budget2 = discoveryByteBudget()) {
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
     return sha2562;
   }
+  if (source.hashMode === "claude-marketplace-entry-v1") {
+    if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256) || changes?.has(source.path) || !claudeMarketplaceEntrySourceValid(source))
+      throw new Error("Claude marketplace entry witnesses require an exact reviewed entry without synthetic changes");
+    const sha2562 = captureClaudeMarketplaceEntry(source.path, source.marketplace, source.plugin, budget2).sha256;
+    if (sha2562 !== source.sha256)
+      throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
+    return sha2562;
+  }
   if (source.hashMode === "claude-plugin-registry") {
     if (source.format !== undefined || source.fields !== undefined || !source.managedPlugins || changes?.has(source.path))
       throw new Error("Managed plugin registry witnesses require verified native registrations");
@@ -50647,7 +50881,7 @@ function absentCodexSkillRoots(binding) {
     throw new Error("Invalid disabled Codex discovery proof");
   if (binding.method !== "reviewed" || controls.every((control) => lstatSync18(control.pluginParent, { throwIfNoEntry: false })))
     return [];
-  const cache = dirname15(dirname15(controls[0].pluginParent)), config2 = join26(dirname15(dirname15(cache)), "config.toml");
+  const cache = dirname16(dirname16(controls[0].pluginParent)), config2 = join26(dirname16(dirname16(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config2 && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
   if (!source || projected(source) !== source.sha256)
     throw new Error("Missing current disabled Codex configuration witness");
@@ -50655,7 +50889,7 @@ function absentCodexSkillRoots(binding) {
   return [...new Set(controls.map((control) => control.pluginParent))].filter((parent) => !codexDirectHookSelects(cache, parent) && absentDisabledCodexPluginParent(cache, parent, controls, rules));
 }
 function codexDirectHookSelects(cache, root) {
-  const codex = dirname15(dirname15(cache)), config2 = Bun.TOML.parse(read(join26(codex, "config.toml")) ?? "");
+  const codex = dirname16(dirname16(cache)), config2 = Bun.TOML.parse(read(join26(codex, "config.toml")) ?? "");
   const hooks = read(join26(codex, "hooks.json"));
   if (hooks !== null)
     hashNativeJsonControls(hooks);
@@ -50668,7 +50902,7 @@ function retiredCodexRoots(binding) {
   const controls = binding.codexDisabledPluginSkills;
   if (binding.agent !== "codex" || binding.method !== "reviewed" || !Array.isArray(controls) || !controls.length || !Array.isArray(proof.roots) || proof.roots.length > AGENT_POLICY_LIMITS.discoveryRoots || new Set(proof.roots).size !== proof.roots.length || !Array.isArray(proof.directories) || proof.parents !== undefined && (!Array.isArray(proof.parents) || proof.parents.length > AGENT_POLICY_LIMITS.discoveryRoots || new Set(proof.parents).size !== proof.parents.length) || !proof.roots.length && !proof.parents?.length)
     throw new Error("Invalid retired Codex materialization proof");
-  const cache = dirname15(dirname15(controls[0].pluginParent)), config2 = join26(dirname15(dirname15(cache)), "config.toml");
+  const cache = dirname16(dirname16(controls[0].pluginParent)), config2 = join26(dirname16(dirname16(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config2 && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
   if (!source || projected(source) !== source.sha256)
     throw new Error("Missing current retired Codex configuration witness");
@@ -50699,7 +50933,7 @@ function absentRetiredClaudeRoots(binding) {
     safe4(root);
     if (lstatSync18(root, { throwIfNoEntry: false }))
       continue;
-    const claude = dirname15(dirname15(cache)), settings = join26(claude, "settings.json"), registry2 = join26(claude, "plugins/installed_plugins.json");
+    const claude = dirname16(dirname16(cache)), settings = join26(claude, "settings.json"), registry2 = join26(claude, "plugins/installed_plugins.json");
     const full = (path) => binding.sources.find((item) => item.path === path && item.sha256 !== null && item.format === undefined && item.fields === undefined);
     const configSource = full(settings), registrySource = full(registry2);
     if (!configSource || !registrySource || projected(configSource) !== configSource.sha256 || projected(registrySource) !== registrySource.sha256)
@@ -50716,7 +50950,7 @@ function absentRetiredClaudeRoots(binding) {
     if (!Array.isArray(rows) || rows.length !== 1 || rows[0]?.scope !== "user" || typeof rows[0]?.installPath !== "string")
       continue;
     const active = rows[0].installPath;
-    if (rows[0].version !== basename8(active) || resolve15(active) !== active || dirname15(active) !== dirname15(root) || active === root || !lstatSync18(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync5(active) !== active)
+    if (rows[0].version !== basename9(active) || resolve17(active) !== active || dirname16(active) !== dirname16(root) || active === root || !lstatSync18(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync5(active) !== active)
       continue;
     const activeManifest = full(join26(active, ".claude-plugin/plugin.json"));
     if (!activeManifest || projected(activeManifest) !== activeManifest.sha256)
@@ -50767,7 +51001,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
     assertMarketplaceBinding(binding, source);
     if (source.hashMode === "claude-plugin-registry" && binding.agent !== "claude")
       throw new Error("Managed Claude registry witnesses cannot apply to another agent");
-    if (source.format !== undefined && (!["json", "toml", "yaml"].includes(source.format) || !Array.isArray(source.fields) || !source.fields.length || source.fields.length > 64 || source.fields.some((field2) => typeof field2 !== "string" || !field2)))
+    if (source.format !== undefined && (!["json", "toml", "yaml"].includes(source.format) || !Array.isArray(source.fields) || !source.fields.length || source.fields.length > 64 || source.fields.some((field3) => typeof field3 !== "string" || !field3)))
       throw new Error("Invalid native discovery projection");
     if (source.sha256 !== null && !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Invalid native discovery digest");
@@ -50795,15 +51029,15 @@ function codexInstallationRoots(binding) {
   const proof = binding.codexInstallationInputs;
   if (proof === undefined)
     return [];
-  if (binding.agent !== "codex" || binding.method !== "reviewed" || proof.version !== "codex-cli 0.160.0" || !/^[a-f0-9]{64}$/.test(proof.catalogSha256) || !Array.isArray(proof.plugins) || !proof.plugins.length)
+  if (binding.agent !== "codex" || binding.method !== "reviewed" || !supportsCodexNativeCapability(proof.version, "installed-plugin-review") || !/^[a-f0-9]{64}$/.test(proof.catalogSha256) || !Array.isArray(proof.plugins) || !proof.plugins.length)
     throw new Error("Invalid native installation input proof");
-  const cache = dirname15(dirname15(proof.plugins[0].pluginParent));
-  const config2 = join26(dirname15(dirname15(cache)), "config.toml"), home = dirname15(dirname15(dirname15(cache)));
+  const cache = dirname16(dirname16(proof.plugins[0].pluginParent));
+  const config2 = join26(dirname16(dirname16(cache)), "config.toml"), home = dirname16(dirname16(dirname16(cache)));
   const configSource = binding.sources.find((source) => source.path === config2 && source.sha256 !== null && (!source.format || source.format === "toml" && source.fields?.includes("plugins")));
   const nativeRoots = NATIVE_SKILL_ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => join26(home, path));
-  if (!configSource || proof.plugins.some((input2) => nativeRoots.some((root) => root === input2.sourceRoot || root.startsWith(input2.sourceRoot + sep6) || input2.sourceRoot.startsWith(root + sep6)) || binding.sources.some((source) => basename8(source.path) === "config.toml" && (source.path === input2.sourceRoot || source.path.startsWith(input2.sourceRoot + sep6)))))
+  if (!configSource || proof.plugins.some((input2) => nativeRoots.some((root) => root === input2.sourceRoot || root.startsWith(input2.sourceRoot + sep6) || input2.sourceRoot.startsWith(root + sep6)) || binding.sources.some((source) => basename9(source.path) === "config.toml" && (source.path === input2.sourceRoot || source.path.startsWith(input2.sourceRoot + sep6)))))
     throw new Error("Native installation input overlaps configuration or loading roots");
-  if (proof.plugins.some((input2) => dirname15(dirname15(input2.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join26(input2.sourceRoot, ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined)))
+  if (proof.plugins.some((input2) => dirname16(dirname16(input2.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join26(input2.sourceRoot, ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined)))
     throw new Error("Missing native installation input source witness");
   return reviewedCodexPluginSourceRoots(cache, proof.plugins, (path) => {
     const text2 = read(path);
@@ -50813,16 +51047,18 @@ function codexInstallationRoots(binding) {
   });
 }
 function assertMarketplaceBinding(binding, source) {
-  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename8(source.path) !== "plugin.json" || !source.path.endsWith(join26(sep6, ".claude-plugin", "plugin.json"))))
+  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename9(source.path) !== "plugin.json" || !source.path.endsWith(join26(sep6, ".claude-plugin", "plugin.json"))))
     throw new Error("Claude plugin manifest witnesses require Claude plugin discovery");
-  if (source.hashMode === "sumi-settings-v1" && (binding.agent !== "sumi" || binding.method !== "reviewed" || basename8(source.path) !== "sumi.json"))
+  if (source.hashMode === "sumi-settings-v1" && (binding.agent !== "sumi" || binding.method !== "reviewed" || basename9(source.path) !== "sumi.json"))
     throw new Error("Sumi settings witnesses require explicit reviewed Sumi configuration");
-  if ((source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")) && (binding.agent !== "codex" || binding.method !== "reviewed" || basename8(source.path) !== "config.toml"))
+  if ((source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")) && (binding.agent !== "codex" || binding.method !== "reviewed" || basename9(source.path) !== "config.toml"))
     throw new Error("Codex settings witnesses require explicit reviewed Codex configuration");
-  if ((source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4")) && (binding.agent !== "claude" || binding.method !== "reviewed" || basename8(source.path) !== "settings.json"))
+  if ((source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4")) && (binding.agent !== "claude" || binding.method !== "reviewed" || basename9(source.path) !== "settings.json"))
     throw new Error("Claude settings witnesses require explicit reviewed Claude configuration");
   if ((source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2") && (binding.agent !== "claude" || binding.method !== "reviewed"))
     throw new Error("Claude marketplace witnesses require explicit reviewed Claude discovery");
+  if (source.hashMode === "claude-marketplace-entry-v1" && (binding.agent !== "claude" || binding.method !== "reviewed" || !claudeMarketplaceEntrySourceValid(source)))
+    throw new Error("Claude marketplace entry witnesses require explicit reviewed Claude discovery of one named entry");
 }
 function agentDiscoveryConfigPath(home, agent) {
   if (agent === "sumi")
@@ -50830,10 +51066,10 @@ function agentDiscoveryConfigPath(home, agent) {
   return join26(home, agent === "hermes" ? ".hermes/config.yaml" : agent === "opencode" ? ".config/opencode/opencode.json" : `.${agent}/${agent === "codex" ? "config.toml" : agent === "cursor" ? "hooks.json" : "settings.json"}`);
 }
 function resolveAgentDiscovery(options) {
-  const canonical7 = options.canonical ?? resolve15, home = resolve15(options.home), agent = options.agent;
+  const canonical8 = options.canonical ?? resolve17, home = resolve17(options.home), agent = options.agent;
   const sources = [], roots = new Set, builtinNames = [];
   const witness = (path, format, fields2, hashMode) => {
-    const source = { path: canonical7(path), sha256: null, ...format ? { format, fields: fields2 } : {}, ...hashMode ? { hashMode } : {} };
+    const source = { path: canonical8(path), sha256: null, ...format ? { format, fields: fields2 } : {}, ...hashMode ? { hashMode } : {} };
     source.sha256 = projected(source);
     sources.push(source);
     return read(source.path);
@@ -50855,13 +51091,13 @@ function resolveAgentDiscovery(options) {
       unresolved("JSONC configuration requires a supported format adapter");
     for (const root of [directory, join26(home, ".claude"), join26(home, ".agents")])
       for (const name of ["skill", "skills"])
-        roots.add(canonical7(join26(root, name)));
+        roots.add(canonical8(join26(root, name)));
     if (config2.skills !== undefined && (!Array.isArray(config2.skills) || config2.skills.some((path) => typeof path !== "string")))
       unresolved("skills must be a string array");
     for (const value of config2.skills ?? []) {
-      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute13(value) || value.startsWith("~/")))
+      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute15(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
-      roots.add(canonical7(value.startsWith("~/") ? join26(home, value.slice(2)) : value));
+      roots.add(canonical8(value.startsWith("~/") ? join26(home, value.slice(2)) : value));
     }
     for (const key of ["plugin", "plugins"])
       if (config2[key] !== undefined && !Array.isArray(config2[key]))
@@ -50900,23 +51136,23 @@ function resolveAgentDiscovery(options) {
         continue;
       if (normalized.startsWith("~") && normalized !== "~" && !normalized.startsWith("~/"))
         unresolved("user-specific tilde expansion requires a separate discovery adapter");
-      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join26(home, normalized.slice(2)) : resolve15(home, ".hermes", normalized);
+      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join26(home, normalized.slice(2)) : resolve17(home, ".hermes", normalized);
       safe4(path);
       roots.add(path);
     }
   }
   if (agent === "gemini") {
-    const executable = Bun.which("gemini");
+    const executable = options.executable === undefined ? discoveryExecutable(agent) : options.executable;
     if (executable) {
       let packageRoot;
-      for (let directory = dirname15(realpathSync5(executable)), depth = 0;depth < 8; directory = dirname15(directory), depth++) {
+      for (let directory = dirname16(executable.target), depth = 0;depth < 8; directory = dirname16(directory), depth++) {
         const path = join26(directory, "package.json"), raw = read(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname15(directory) === directory)
+        if (dirname16(directory) === directory)
           break;
       }
       if (!packageRoot)
@@ -50939,11 +51175,11 @@ function resolveAgentDiscovery(options) {
     if (retained.agent !== agent || retained.method !== "reviewed")
       unresolved("invalid retained review");
     verifyAgentDiscovery(retained);
-    if (!retained.sources.some((source) => source.path === canonical7(configPath) && source.format === undefined && source.fields === undefined))
+    if (!retained.sources.some((source) => source.path === canonical8(configPath) && source.format === undefined && source.fields === undefined))
       unresolved("retained review is missing the full agent configuration source");
-    if (retained.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical7(configPath)))
+    if (retained.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical8(configPath)))
       unresolved("retained settings witness names another configuration source");
-    const covered = supersedesSettingsProjection(agent, retained.sources, canonical7(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical7(configPath), source)) : sources;
+    const covered = supersedesSettingsProjection(agent, retained.sources, canonical8(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical8(configPath), source)) : sources;
     if (covered.some((source) => !retained.sources.some((saved) => isDeepStrictEqual4(saved, source))) || [...roots].some((root) => !retained.roots.includes(root)) || agent === "gemini" && JSON.stringify(retained.builtinNames) !== JSON.stringify(builtinNames))
       unresolved("retained review is missing current runtime discovery coverage");
     return retained;
@@ -50955,15 +51191,15 @@ function resolveAgentDiscovery(options) {
     if (review.sources.some((source) => source.format !== undefined || source.fields !== undefined))
       throw new Error("Explicit discovery reviews require full source-file hashes");
     verifyAgentDiscovery(supplied);
-    if (review.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical7(configPath)))
+    if (review.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical8(configPath)))
       throw new Error("Semantic settings witnesses must name the configured agent configuration source");
-    if (!review.sources.some((source) => source.path === canonical7(configPath)))
+    if (!review.sources.some((source) => source.path === canonical8(configPath)))
       throw new Error("Discovery review must include the agent configuration source");
-    const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical7(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical7(configPath), source)) : sources;
+    const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical8(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical8(configPath), source)) : sources;
     const reviewedSourcesWithManifestProjection = review.sources.map((source) => {
-      if (agent !== "claude" || source.sha256 === null || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename8(source.path) !== "plugin.json" || !source.path.endsWith(join26(sep6, ".claude-plugin", "plugin.json")))
+      if (agent !== "claude" || source.sha256 === null || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename9(source.path) !== "plugin.json" || !source.path.endsWith(join26(sep6, ".claude-plugin", "plugin.json")))
         return source;
-      const pluginRoot = dirname15(dirname15(source.path)), hooksPath = join26(pluginRoot, "hooks/hooks.json");
+      const pluginRoot = dirname16(dirname16(source.path)), hooksPath = join26(pluginRoot, "hooks/hooks.json");
       const hookStat = lstatSync18(hooksPath, { throwIfNoEntry: false });
       const text2 = read(source.path);
       if (text2 === null)
@@ -50978,13 +51214,13 @@ function resolveAgentDiscovery(options) {
       if (manifest.hooks !== undefined) {
         if (typeof manifest.hooks !== "string")
           throw new Error("Reviewed Claude plugin manifest has an unsupported hooks target");
-        const declaredHookPath = resolve15(pluginRoot, manifest.hooks);
+        const declaredHookPath = resolve17(pluginRoot, manifest.hooks);
         if (!declaredHookPath.startsWith(pluginRoot + sep6))
           throw new Error("Reviewed Claude plugin hooks target escapes its root");
         reviewedHookPaths.add(declaredHookPath);
       }
       for (const hooksFile of reviewedHookPaths)
-        if (!review.sources.some((hook) => hook.path === canonical7(hooksFile) && hook.sha256 !== null && hook.format === undefined && hook.fields === undefined && hook.managedPlugins === undefined && (hook.hashMode === undefined || hook.hashMode === "bytes")))
+        if (!review.sources.some((hook) => hook.path === canonical8(hooksFile) && hook.sha256 !== null && hook.format === undefined && hook.fields === undefined && hook.managedPlugins === undefined && (hook.hashMode === undefined || hook.hashMode === "bytes")))
           throw new Error("Reviewed Claude plugin manifest requires separately reviewed exact hook file sources");
       return { path: source.path, sha256: manifestSha256, hashMode: "claude-plugin-manifest-v1" };
     });
@@ -50993,7 +51229,7 @@ function resolveAgentDiscovery(options) {
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: unique, ...agent === "gemini" ? { builtinNames } : {} };
   }
   function plugin(root) {
-    root = canonical7(root);
+    root = canonical8(root);
     safe4(root);
     const manifestPath = join26(root, agent === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
     const raw = witness(manifestPath, undefined, undefined, agent === "claude" ? "claude-plugin-manifest-v1" : undefined);
@@ -51016,16 +51252,16 @@ function resolveAgentDiscovery(options) {
     if (agent === "claude")
       roots.add(join26(root, "skills"));
     for (const value of declared) {
-      const path = resolve15(root, value);
+      const path = resolve17(root, value);
       if (path !== root && !path.startsWith(root + sep6))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep6}SKILL.md`) ? dirname15(path) : path);
+      roots.add(path.endsWith(`${sep6}SKILL.md`) ? dirname16(path) : path);
     }
   }
   if (agent === "claude") {
     const registrations = witness(join26(home, ".claude/plugins/installed_plugins.json"));
     const installed = registrations === null ? {} : parseConfig(registrations, join26(home, ".claude/plugins/installed_plugins.json")).plugins;
-    const commands = canonical7(join26(home, ".claude/commands"));
+    const commands = canonical8(join26(home, ".claude/commands"));
     safe4(commands);
     if (lstatSync18(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync7(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
@@ -51047,7 +51283,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split = id.lastIndexOf("@"), name = id.slice(0, split), marketplace = id.slice(split + 1);
       const market = config2.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute13(market.source))
+      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute15(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join26(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -51055,7 +51291,7 @@ function resolveAgentDiscovery(options) {
       const catalog = parseConfig(catalogText, join26(market.source, ".agents/plugins/marketplace.json")), matches = Array.isArray(catalog.plugins) ? catalog.plugins.filter((item) => item.name === name) : [];
       if (matches.length !== 1 || matches[0]?.source?.source !== "local" || typeof matches[0]?.source?.path !== "string")
         unresolved("plugin catalog source is missing or ambiguous");
-      plugin(resolve15(market.source, matches[0].source.path));
+      plugin(resolve17(market.source, matches[0].source.path));
     }
   } else if (agent === "opencode") {
     if (witness(join26(home, ".config/opencode/opencode.jsonc")) !== null || witness(join26(home, ".config/opencode/config.json")) !== null)
@@ -51063,7 +51299,7 @@ function resolveAgentDiscovery(options) {
     if ((config2.plugin?.length ?? 0) > 0 || config2.skills?.urls?.length)
       unresolved("external plugin or remote skill source");
     for (const path of config2.skills?.paths ?? []) {
-      if (typeof path !== "string" || !isAbsolute13(path))
+      if (typeof path !== "string" || !isAbsolute15(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
@@ -51072,7 +51308,7 @@ function resolveAgentDiscovery(options) {
     if (lstatSync18(localPlugins, { throwIfNoEntry: false }) && readdirSync7(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "sumi") {
-    if ((config2.plugin?.length ?? 0) > 0 || (config2.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical7(configPath) && source.path !== canonical7(join26(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
+    if ((config2.plugin?.length ?? 0) > 0 || (config2.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical8(configPath) && source.path !== canonical8(join26(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
       unresolved("external or foreign local plugins require review");
   } else if (agent === "hermes") {
     for (const directory of [join26(home, ".hermes/plugins"), join26(home, ".hermes/hermes-agent")]) {
@@ -51102,9 +51338,15 @@ function resolveAgentDiscovery(options) {
         roots.add(join26(root, "skills"));
       }
   }
-  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join26(home, ".hermes/plugins"), join26(home, ".hermes/hermes-agent")].map((path) => canonical7(path))) } : {} };
+  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join26(home, ".hermes/plugins"), join26(home, ".hermes/hermes-agent")].map((path) => canonical8(path))) } : {} };
 }
-var digest = (text2) => createHash17("sha256").update(text2).digest("hex");
+var DISCOVERY_RUNTIME_COMMANDS, realpathOrNull = (path) => {
+  try {
+    return realpathSync5(path);
+  } catch {
+    return null;
+  }
+}, digest = (text2) => createHash18("sha256").update(text2).digest("hex");
 var init_agent_discovery = __esm(() => {
   init_sumi_settings_witness();
   init_agent_policy_limits();
@@ -51116,21 +51358,24 @@ var init_agent_discovery = __esm(() => {
   init_plugin_discovery();
   init_plugin_admission();
   init_claude_marketplace_registry();
+  init_claude_marketplace_entry_witness();
   init_claude_settings_witness();
   init_codex_hook_discovery_recovery();
   init_codex_settings_witness();
   init_codex_plugin_skill_controls();
   init_agent_sumi();
   init_native_discovery_roots();
+  init_codex_native_compatibility();
   init_agent_discovery_directories();
+  DISCOVERY_RUNTIME_COMMANDS = Object.freeze({ gemini: "gemini" });
 });
 
 // src/lib/authoring-path.ts
 import { lstatSync as lstatSync19, realpathSync as realpathSync6 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename9, dirname as dirname16, join as join27, resolve as resolve16, sep as sep7 } from "path";
+import { basename as basename10, dirname as dirname17, join as join27, resolve as resolve18, sep as sep7 } from "path";
 function pathParts(path) {
-  return resolve16(path).split(sep7).filter(Boolean);
+  return resolve18(path).split(sep7).filter(Boolean);
 }
 function nativeRootMatch(path) {
   const parts = pathParts(path);
@@ -51144,16 +51389,16 @@ function nativeRootMatch(path) {
   return;
 }
 function physicalPath(path) {
-  let cursor = resolve16(path);
+  let cursor = resolve18(path);
   const suffix = [];
   while (!lstatSync19(cursor, { throwIfNoEntry: false })) {
-    suffix.unshift(basename9(cursor));
-    const parent = dirname16(cursor);
+    suffix.unshift(basename10(cursor));
+    const parent = dirname17(cursor);
     if (parent === cursor)
-      return resolve16(path);
+      return resolve18(path);
     cursor = parent;
   }
-  return resolve16(realpathSync6(cursor), ...suffix);
+  return resolve18(realpathSync6(cursor), ...suffix);
 }
 function contains(root, path) {
   return path === root || path.startsWith(root + sep7);
@@ -51161,7 +51406,7 @@ function contains(root, path) {
 function configuredRoots(home, explicitHome) {
   const homeData = join27(home, ".hasna", "skills");
   const homePolicy = readManagedSkillPolicySnapshot(homeData);
-  const configuredPolicy = !explicitHome && resolve16(getDataDirReadOnly()) !== resolve16(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
+  const configuredPolicy = !explicitHome && resolve18(getDataDirReadOnly()) !== resolve18(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
   const policy = homePolicy ?? configuredPolicy;
   const bridge = policy?.value.bridge;
   if (bridge && (typeof bridge.home !== "string" || physicalPath(bridge.home) !== physicalPath(home))) {
@@ -51200,22 +51445,22 @@ function configuredRoots(home, explicitHome) {
 function assertPortableAuthoringPath(path, options = {}) {
   if (typeof path !== "string" || !path || path.includes("\x00"))
     throw new Error("Invalid portable authoring path");
-  const lexical = resolve16(path);
+  const lexical = resolve18(path);
   const physical = physicalPath(lexical);
   const candidates = [lexical, physical];
   let native = candidates.map(nativeRootMatch).find(Boolean);
-  const home = resolve16(options.homeDir ?? homedir3());
+  const home = resolve18(options.homeDir ?? homedir3());
   const defaults = NATIVE_DISCOVERY_ROOTS.map((parts) => join27(home, ...parts));
   defaults.push(join27(home, ".codex/plugins/cache"), join27(home, ".claude/plugins/cache"), join27(home, ".claude/plugins/synced"), join27(home, ".gemini/extensions"));
   for (const root of defaults) {
-    if (candidates.some((candidate) => contains(resolve16(root), candidate) || contains(physicalPath(root), candidate)))
+    if (candidates.some((candidate) => contains(resolve18(root), candidate) || contains(physicalPath(root), candidate)))
       native ??= root;
   }
   if (native) {
     throw new Error(`Refusing portable Skills authoring below native discovery root '${native}': ${lexical}. Set HASNA_SKILLS_DIR to a private authoring corpus outside native roots.`);
   }
   for (const root of configuredRoots(home, options.homeDir !== undefined)) {
-    if (candidates.some((candidate) => contains(resolve16(root), candidate) || contains(physicalPath(root), candidate))) {
+    if (candidates.some((candidate) => contains(resolve18(root), candidate) || contains(physicalPath(root), candidate))) {
       throw new Error(`Refusing portable Skills authoring below configured native discovery root: ${lexical}`);
     }
   }
@@ -51242,7 +51487,7 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync6
 } from "fs";
-import { basename as basename10, dirname as dirname17, isAbsolute as isAbsolute14, join as join28, normalize as normalize3, relative as relative5, resolve as resolve17, sep as sep8 } from "path";
+import { basename as basename11, dirname as dirname18, isAbsolute as isAbsolute16, join as join28, normalize as normalize3, relative as relative5, resolve as resolve19, sep as sep8 } from "path";
 function getPortableSkillsRoot(options = {}) {
   return resolvePortableSkillsRoot(options, true);
 }
@@ -51337,20 +51582,20 @@ function scaffoldPortableSkill(name, options = {}) {
   return { name: skillName, path: skillPath, manifest, created: true };
 }
 function physicalImportPath(path) {
-  let ancestor = resolve17(path);
+  let ancestor = resolve19(path);
   const suffix = [];
   while (!existsSync12(ancestor)) {
-    suffix.unshift(basename10(ancestor));
-    ancestor = dirname17(ancestor);
+    suffix.unshift(basename11(ancestor));
+    ancestor = dirname18(ancestor);
   }
   return join28(realpathSync7(ancestor), ...suffix);
 }
 function assertDisjointImportPaths(source, destination) {
   const sourcePath = realpathSync7(source);
   const destinationPath = physicalImportPath(destination);
-  const contains2 = (parent, child) => {
-    const path = relative5(parent, child);
-    return path === "" || !isAbsolute14(path) && path !== ".." && !path.startsWith(`..${sep8}`);
+  const contains2 = (parent, child2) => {
+    const path = relative5(parent, child2);
+    return path === "" || !isAbsolute16(path) && path !== ".." && !path.startsWith(`..${sep8}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -51365,8 +51610,8 @@ function portPortableSkill(sourcePath, options = {}) {
   const explicitName = options.name != null;
   const skillName = normalizeNewPortableSkillName(options.name ?? inferred.name);
   if (isOfficialSkillName(skillName) && !options.allowShadow) {
-    const sourceSlug = safeNormalizeName(basename10(absoluteSource));
-    const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename10(absoluteSource)}')` : ""} matches a bundled official skill.`;
+    const sourceSlug = safeNormalizeName(basename11(absoluteSource));
+    const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename11(absoluteSource)}')` : ""} matches a bundled official skill.`;
     throw new Error(`${via} Importing it would shadow the official '${skillName}'. ` + `Pass --name to choose a different name, or --allow-shadow to override deliberately.`);
   }
   const readOnlyDestination = join28(resolvePortableSkillsRoot(options, false), skillName);
@@ -51381,7 +51626,7 @@ function portPortableSkill(sourcePath, options = {}) {
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync3(destination, { recursive: true, force: true });
   }
-  mkdirSync7(dirname17(destination), { recursive: true });
+  mkdirSync7(dirname18(destination), { recursive: true });
   copySkillDirectory(absoluteSource, destination);
   const base = {
     ...inferred,
@@ -51515,7 +51760,7 @@ function safeIsDirectory(path) {
   }
 }
 function isSafeRelativePath2(value) {
-  if (!value.trim() || isAbsolute14(value))
+  if (!value.trim() || isAbsolute16(value))
     return false;
   const normalized = normalize3(value).replace(/\\/g, "/");
   return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
@@ -52144,11 +52389,14 @@ var init_skill_context = __esm(() => {
 });
 
 // src/lib/session-reconciliation.ts
-var SESSION_RECONCILIATION_PLAN_TTL_MS;
+var SESSION_RECONCILIATION_PLAN_TTL_MS, SESSION_RENEWAL_REFUSAL_TTL_MS, SESSION_RENEWAL_REFUSAL_MAX_BYTES;
 var init_session_reconciliation = __esm(() => {
   init_profile_client();
+  init_skill_bundle();
   init_selection_cache();
   SESSION_RECONCILIATION_PLAN_TTL_MS = 5 * 60 * 1000;
+  SESSION_RENEWAL_REFUSAL_TTL_MS = 5 * 60 * 1000;
+  SESSION_RENEWAL_REFUSAL_MAX_BYTES = 4 * 1024;
 });
 
 // src/cli/commands/context.ts
@@ -52186,7 +52434,7 @@ var init_remote_customer_operations = __esm(() => {
 });
 
 // src/lib/canonical-json.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -52230,7 +52478,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash18("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash19("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 var init_canonical_json = () => {};
 
@@ -52981,13 +53229,13 @@ var init_remote_workspace_leave = __esm(() => {
 
 // src/lib/auth-store.ts
 import { chmodSync, existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync17, renameSync as renameSync4, statSync as statSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename11, dirname as dirname18, join as join30 } from "path";
+import { basename as basename12, dirname as dirname19, join as join30 } from "path";
 function getAuthFilePath(env = process.env) {
   return skillsCredentialFilePath(env);
 }
 function getIdentityFilePath(env = process.env) {
   const file2 = skillsCredentialFilePath(env);
-  return join30(dirname18(file2), basename11(file2).replace(/^credentials/, "identity") + ".json");
+  return join30(dirname19(file2), basename12(file2).replace(/^credentials/, "identity") + ".json");
 }
 function getApiUrl(action, env = process.env, options = {}) {
   return requireSkillsApiOrigin(action, env, options);
@@ -53069,17 +53317,17 @@ function runQuoteReceipt(value) {
   return value;
 }
 function parseRemoteRunQuote(value) {
-  const quote2 = object7(value);
-  runQuoteReceipt(quote2.quoteReceipt);
-  const pricing = object7(quote2.pricing);
-  if (typeof quote2.skill !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(quote2.skill))
+  const quote3 = object7(value);
+  runQuoteReceipt(quote3.quoteReceipt);
+  const pricing = object7(quote3.pricing);
+  if (typeof quote3.skill !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(quote3.skill))
     throw new Error("Invalid quoted skill");
   const costCents = creditCount(pricing.costCredits ?? pricing.costCents);
   if (pricing.costCredits !== undefined && pricing.costCents !== undefined && pricing.costCents !== costCents)
     throw new Error("Inconsistent quoted credit count");
-  if (quote2.availability && object7(quote2.availability).status !== "available")
+  if (quote3.availability && object7(quote3.availability).status !== "available")
     throw new Error("This skill is unavailable for remote execution");
-  return { ...quote2, skill: quote2.skill, pricing: { ...pricing, costCredits: costCents, costCents, formattedCost: `${costCents} credits` } };
+  return { ...quote3, skill: quote3.skill, pricing: { ...pricing, costCredits: costCents, costCents, formattedCost: `${costCents} credits` } };
 }
 function parseRemoteCreditPacks(value) {
   if (!Array.isArray(value))
@@ -53171,14 +53419,14 @@ var init_remote_credit_checkout = __esm(() => {
 });
 
 // src/lib/remote-profile.ts
-function customerNamePatch(input2, field2) {
-  if (!isRecord5(input2) || Object.keys(input2).length !== 1 || !Object.hasOwn(input2, field2))
+function customerNamePatch(input2, field3) {
+  if (!isRecord5(input2) || Object.keys(input2).length !== 1 || !Object.hasOwn(input2, field3))
     throw new Error("Provide only the requested name field.");
-  const value = input2[field2];
+  const value = input2[field3];
   if (typeof value !== "string" || /[\p{Cc}\p{Cs}\u2028\u2029]/u.test(value) || !value.trim() || [...value.trim()].length > 100) {
     throw new Error("Use a name of 1\u2013100 characters without control characters or newlines.");
   }
-  return { [field2]: value.trim() };
+  return { [field3]: value.trim() };
 }
 function isRecord5(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -53215,10 +53463,10 @@ async function readQuoteUnavailableCode(response) {
   let timer;
   let deadlineExceeded = false;
   const expired = Symbol("quote body deadline");
-  const deadline = new Promise((resolve18) => {
+  const deadline = new Promise((resolve20) => {
     timer = setTimeout(() => {
       deadlineExceeded = true;
-      resolve18(expired);
+      resolve20(expired);
       reader.cancel().catch(() => {});
     }, 1500);
   });
@@ -53501,18 +53749,18 @@ class RemoteSkillsClient {
     const maximum = creditCount(approval.maxCredits ?? approval.maxCostCents ?? 0);
     if (approval.maxCostCents !== undefined && approval.maxCostCents !== maximum)
       throw new Error("Credit approval fields disagree");
-    const quote2 = approval.quoteReceipt === undefined ? await this.quoteRun(slug2, input2, args, approval.inputFiles?.length ? approval.inputFiles : undefined) : undefined;
-    if (quote2 && quote2.pricing.costCents > maximum)
-      throw new RemoteCreditApprovalError(quote2.pricing.costCents, maximum);
+    const quote3 = approval.quoteReceipt === undefined ? await this.quoteRun(slug2, input2, args, approval.inputFiles?.length ? approval.inputFiles : undefined) : undefined;
+    if (quote3 && quote3.pricing.costCents > maximum)
+      throw new RemoteCreditApprovalError(quote3.pricing.costCents, maximum);
     const capabilities = await this.getCapabilities();
     if (!capabilities.capabilities.includes("runs.submit") || capabilities.billing?.boundedRunApproval !== true || capabilities.billing.unit !== "credits") {
       throw new Error("The configured server does not support bounded credit approval; refusing remote submission");
     }
-    return this.submitRun(quote2?.skill ?? slug2, input2, args, {
+    return this.submitRun(quote3?.skill ?? slug2, input2, args, {
       ...approval,
       maxCredits: maximum,
       maxCostCents: maximum,
-      ...(quote2?.quoteReceipt ?? approval.quoteReceipt) === undefined ? {} : { quoteReceipt: quote2?.quoteReceipt ?? approval.quoteReceipt }
+      ...(quote3?.quoteReceipt ?? approval.quoteReceipt) === undefined ? {} : { quoteReceipt: quote3?.quoteReceipt ?? approval.quoteReceipt }
     });
   }
   async getIdentity() {
@@ -54113,13 +54361,13 @@ class RemoteSkillsClient {
     return normalizeUpdatedSincePage(await response.json());
   }
 }
-function requireOptionalString(record9, field2) {
-  if (record9[field2] === undefined)
+function requireOptionalString(record9, field3) {
+  if (record9[field3] === undefined)
     return;
-  if (typeof record9[field2] !== "string") {
-    throw new Error(`Remote payload did not match the expected contract (${field2} must be a string when present)`);
+  if (typeof record9[field3] !== "string") {
+    throw new Error(`Remote payload did not match the expected contract (${field3} must be a string when present)`);
   }
-  return record9[field2];
+  return record9[field3];
 }
 function isVersionRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -54456,7 +54704,7 @@ var init_remote_invitation_recovery = __esm(() => {
 });
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function checkedPublicationDeclaration(value) {
   if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash3(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -54701,12 +54949,12 @@ class RemotePrivatePublicationsClient {
       previous = view;
       if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
         return view;
-      await new Promise((resolve18) => {
+      await new Promise((resolve20) => {
         const timer = setTimeout(done, Math.min(1000, until - Date.now()));
         function done() {
           clearTimeout(timer);
           options.signal?.removeEventListener("abort", done);
-          resolve18();
+          resolve20();
         }
         options.signal?.addEventListener("abort", done, { once: true });
       });
@@ -54717,7 +54965,7 @@ var PRIVATE_PUBLICATION_MAX_BYTES, failures2, PrivatePublicationError, bad = ()
   throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
 }, invalid4 = () => {
   throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
-}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys) => record10(v) && Object.keys(v).sort().join(",") === keys.sort().join(","), date6 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash19("sha256").update(bytes).digest("hex");
+}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys) => record10(v) && Object.keys(v).sort().join(",") === keys.sort().join(","), date6 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash20("sha256").update(bytes).digest("hex");
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -55227,7 +55475,7 @@ var init_recurring_customer = __esm(() => {
 
 // src/lib/recurring-recovery.ts
 import { constants as constants12, closeSync as closeSync15, fsyncSync as fsyncSync4, fstatSync as fstatSync15, lstatSync as lstatSync21, mkdirSync as mkdirSync10, openSync as openSync15, readSync as readSync10, realpathSync as realpathSync8, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname19, isAbsolute as isAbsolute15, join as join31, resolve as resolve18 } from "path";
+import { dirname as dirname20, isAbsolute as isAbsolute17, join as join31, resolve as resolve20 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 
 class RecoveryOwner {
@@ -55235,14 +55483,14 @@ class RecoveryOwner {
   parents = [];
   constructor(directory) {
     this.directory = directory;
-    if (!isAbsolute15(directory) || resolve18(directory) !== directory || realpathSync8(directory) !== directory)
+    if (!isAbsolute17(directory) || resolve20(directory) !== directory || realpathSync8(directory) !== directory)
       invalid5();
-    for (let path = directory;; path = dirname19(path)) {
+    for (let path = directory;; path = dirname20(path)) {
       const stat3 = lstatSync21(path);
       if (!stat3.isDirectory() || stat3.isSymbolicLink())
         invalid5();
       this.parents.push({ path, dev: stat3.dev, ino: stat3.ino });
-      if (path === dirname19(path))
+      if (path === dirname20(path))
         break;
     }
     this.assert();
@@ -55370,7 +55618,7 @@ function base(customer, organizationId) {
   };
 }
 function create(directory, intent) {
-  if (!isAbsolute15(directory) || resolve18(directory) !== directory || realpathSync8(dirname19(directory)) !== dirname19(directory))
+  if (!isAbsolute17(directory) || resolve20(directory) !== directory || realpathSync8(dirname20(directory)) !== dirname20(directory))
     invalid5();
   mkdirSync10(directory, { mode: 448 });
   const owner2 = new RecoveryOwner(directory), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -55533,7 +55781,7 @@ var init_recurring_recovery = __esm(() => {
 });
 
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute16 } from "path";
+import { isAbsolute as isAbsolute18 } from "path";
 function recurringMcpSchema(action) {
   return action === "activate" ? recurringSurfaceSchemas.activate.extend({ code, confirm: exports_external.literal(true) }) : recurringSurfaceSchemas[action];
 }
@@ -55638,7 +55886,7 @@ var init_recurring_surface = __esm(() => {
   uuid13 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   context = { userId: uuid13.optional(), membershipId: uuid13.optional() };
   page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-  directory = exports_external.string().max(4096).refine(isAbsolute16, "Use an absolute recovery directory");
+  directory = exports_external.string().max(4096).refine(isAbsolute18, "Use an absolute recovery directory");
   email4 = exports_external.string().trim().toLowerCase().email().max(254);
   code = exports_external.string().regex(/^\d{6}$/);
   recurringSurfaceSchemas = {
@@ -57467,7 +57715,7 @@ var init_credential_state = __esm(() => {
 });
 
 // src/lib/run-state.ts
-import { createHash as createHash20, randomBytes } from "crypto";
+import { createHash as createHash21, randomBytes } from "crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync19, readdirSync as readdirSync10, statSync as statSync9, writeFileSync as writeFileSync10 } from "fs";
 import { extname, join as join32, relative as relative6 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
@@ -57582,7 +57830,7 @@ function collectRunArtifacts(context2) {
     artifacts.push({
       path: toProjectRelative(context2.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash20("sha256").update(bytes).digest("hex"),
+      sha256: createHash21("sha256").update(bytes).digest("hex"),
       sizeBytes: stat3.size
     });
   }
@@ -57828,12 +58076,12 @@ function parseExecution(value) {
   ].includes(v.status) || typeof v.skill !== "string" || typeof v.version !== "string" || !Array.isArray(v.artifacts))
     throw Error("Unsupported cloud execution response");
   runId(v.id);
-  for (const field2 of [
+  for (const field3 of [
     "bundleDigest",
     "inputDigest",
     "runtimeImageDigest"
   ])
-    if (typeof v[field2] !== "string" || !/^(sha256:)?[a-f0-9]{64}$/.test(v[field2]))
+    if (typeof v[field3] !== "string" || !/^(sha256:)?[a-f0-9]{64}$/.test(v[field3]))
       throw Error("Invalid cloud execution integrity receipt");
   return v;
 }
@@ -57858,7 +58106,7 @@ import { closeSync as closeSync16, fstatSync as fstatSync16, openSync as openSyn
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
-import { isAbsolute as isAbsolute17, join as join33 } from "path";
+import { isAbsolute as isAbsolute19, join as join33 } from "path";
 import { createRequire as createRequire22 } from "module";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -57882,7 +58130,7 @@ function homeDir2(env) {
 }
 function absoluteOverride2(env, key) {
   const value = env[key]?.trim();
-  return value && isAbsolute17(value) ? value : null;
+  return value && isAbsolute19(value) ? value : null;
 }
 function hasnaHomeDir2(env) {
   const override = absoluteOverride2(env, HASNA_HOME_ENV_KEY2);
@@ -57928,9 +58176,9 @@ function parseEnvFile2(text3) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
       continue;
     let value = withoutExport.slice(equals + 1).trim();
-    const quote2 = value[0];
-    if (quote2 === '"' || quote2 === "'") {
-      if (value.length < 2 || !value.endsWith(quote2)) {
+    const quote3 = value[0];
+    if (quote3 === '"' || quote3 === "'") {
+      if (value.length < 2 || !value.endsWith(quote3)) {
         unusable.add(key);
         continue;
       }
@@ -57954,8 +58202,8 @@ function configFileReadsCoherent2(before, after) {
   return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
 }
 function readAppConfigFile2(path) {
-  const unsafe = (reason) => {
-    throw new CredentialFileUnsafeError2(path, reason);
+  const unsafe = (reason2) => {
+    throw new CredentialFileUnsafeError2(path, reason2);
   };
   let fd = -1;
   try {
@@ -58174,8 +58422,8 @@ function readKeychainItem2(name, env, kind, options) {
   try {
     result = run(["find-generic-password", "-a", account, "-s", service, "-w"]);
   } catch (error61) {
-    const reason = keychainFailureHint2(error61 instanceof Error ? error61.message : String(error61));
-    throw new CredentialResolutionError2(name, `The Keychain lookup for ${source} could not run${reason}. A Keychain failure is never resolved ` + `around: fix the keychain, or delete the item to fall through to the credential on disk.`, [source]);
+    const reason2 = keychainFailureHint2(error61 instanceof Error ? error61.message : String(error61));
+    throw new CredentialResolutionError2(name, `The Keychain lookup for ${source} could not run${reason2}. A Keychain failure is never resolved ` + `around: fix the keychain, or delete the item to fall through to the credential on disk.`, [source]);
   }
   if (result.status === KEYCHAIN_ITEM_NOT_FOUND_STATUS2)
     return null;
@@ -59019,7 +59267,7 @@ function createSecretsClientFromEnv(env = process.env, overrides = {}) {
   });
   return new SecretsClient({ ...clientOverrides, baseUrl, apiKey });
 }
-var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), CREDENTIAL_PROFILE_ENV_KEY2 = "HASNA_PROFILE", CredentialResolutionError2, CredentialFileUnsafeError2, HASNA_HOME_ENV_KEY2 = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY2 = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY2 = "HASNA_STATION", HASNA_HOME_DIR2 = ".hasna", CONFIG_SUBDIR2 = "config", CREDENTIALS_FILE2 = "credentials", KEYCHAIN_SECURITY_BIN2 = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX2 = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS2 = 44, KEYCHAIN_SPAWN_TIMEOUT_MS2 = 1e4, MAX_CREDENTIAL_FILE_BYTES2, SAFE_APP_SLUG2, SAFE_PROFILE2, ILLEGAL_IN_HEADER_VALUE2, VAULT_POINTER_SHAPE2, CREDENTIAL_SHAPED_KEY2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider", AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk2, DEFAULT_FLEET_GATEWAY_ORIGIN2 = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN2, DNS_LABEL_PATTERN2, ClientTransportConfigurationError2, HasnaHttpError, DEFAULT_RETRY_STATUSES, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, defaultSleep = (ms) => new Promise((resolve19) => setTimeout(resolve19, ms)), init_transport2, MAX_CREDENTIAL_FILE_BYTES22, INSPECT_CUSTOM22, CREDENTIAL_SEAL22, AMBIENT_ENVIRONMENT22, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk22, IDEMPOTENT_METHODS22, AUTHORITY_OVERRIDE_HEADERS22, init_storage, PATHS_RESOLVER_APP_SLUG_RE2, SQLITE_SIDECAR_FILES, LEGACY_SERVICE_FILES, init_data_dir, SecretsTestIsolationError, TEST_ENTRYPOINT_RE, init_test_isolation, init_client, ApiError;
+var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), CREDENTIAL_PROFILE_ENV_KEY2 = "HASNA_PROFILE", CredentialResolutionError2, CredentialFileUnsafeError2, HASNA_HOME_ENV_KEY2 = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY2 = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY2 = "HASNA_STATION", HASNA_HOME_DIR2 = ".hasna", CONFIG_SUBDIR2 = "config", CREDENTIALS_FILE2 = "credentials", KEYCHAIN_SECURITY_BIN2 = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX2 = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS2 = 44, KEYCHAIN_SPAWN_TIMEOUT_MS2 = 1e4, MAX_CREDENTIAL_FILE_BYTES2, SAFE_APP_SLUG2, SAFE_PROFILE2, ILLEGAL_IN_HEADER_VALUE2, VAULT_POINTER_SHAPE2, CREDENTIAL_SHAPED_KEY2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider", AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk2, DEFAULT_FLEET_GATEWAY_ORIGIN2 = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN2, DNS_LABEL_PATTERN2, ClientTransportConfigurationError2, HasnaHttpError, DEFAULT_RETRY_STATUSES, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, defaultSleep = (ms) => new Promise((resolve21) => setTimeout(resolve21, ms)), init_transport2, MAX_CREDENTIAL_FILE_BYTES22, INSPECT_CUSTOM22, CREDENTIAL_SEAL22, AMBIENT_ENVIRONMENT22, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk22, IDEMPOTENT_METHODS22, AUTHORITY_OVERRIDE_HEADERS22, init_storage, PATHS_RESOLVER_APP_SLUG_RE2, SQLITE_SIDECAR_FILES, LEGACY_SERVICE_FILES, init_data_dir, SecretsTestIsolationError, TEST_ENTRYPOINT_RE, init_test_isolation, init_client, ApiError;
 var init_sdk = __esm(() => {
   init_transport2 = __esm2(() => {
     CredentialResolutionError2 = class CredentialResolutionError3 extends Error {
@@ -59034,8 +59282,8 @@ var init_sdk = __esm(() => {
     };
     CredentialFileUnsafeError2 = class CredentialFileUnsafeError3 extends Error {
       path;
-      constructor(path, reason) {
-        super(`Refusing unsafe credential/config file ${path}: ${reason}.`);
+      constructor(path, reason2) {
+        super(`Refusing unsafe credential/config file ${path}: ${reason2}.`);
         this.name = "CredentialFileUnsafeError";
         this.path = path;
       }
@@ -59396,10 +59644,10 @@ __export(exports_selected_run, {
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
   executeSelectedLocal: () => executeSelectedLocal
 });
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 import { spawn } from "child_process";
 import { mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync11, realpathSync as realpathSync10 } from "fs";
-import { dirname as dirname20, join as join34, resolve as resolve19 } from "path";
+import { dirname as dirname21, join as join34, resolve as resolve21 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
   const context2 = await resolveSelectionContext(profileId, options);
@@ -59488,11 +59736,11 @@ async function executeSelectedLocal(selected, options = {}) {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
     const destination = join34(runDirectory, entry.path);
-    mkdirSync12(dirname20(destination), { recursive: true, mode: 448 });
+    mkdirSync12(dirname21(destination), { recursive: true, mode: 448 });
     writeFileSync11(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
   env.SKILLS_INPUT_JSON = input2;
-  env.SKILLS_WORKSPACE_DIR = resolve19(options.cwd ?? process.cwd());
+  env.SKILLS_WORKSPACE_DIR = resolve21(options.cwd ?? process.cwd());
   env.SKILLS_RUN_DIR = runDirectory;
   if (runtime.version) {
     const version2 = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], "--version"], runDirectory, env, "", Math.min(timeoutMs, 5000));
@@ -59522,7 +59770,7 @@ async function executeSelectedLocal(selected, options = {}) {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
-    inputDigest: `sha256:${createHash21("sha256").update(input2).digest("hex")}`,
+    inputDigest: `sha256:${createHash22("sha256").update(input2).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
     ...bindings ? { secretBinding: { schema: bindings.schema, selection: bindings.selection, consumer: bindings.consumer, secretsAuthority: bindings.secretsAuthority, bindings: bindings.bindings } } : {},
@@ -59533,17 +59781,17 @@ async function executeSelectedLocal(selected, options = {}) {
 }
 async function subprocess(command, cwd, env, input2, timeoutMs) {
   return new Promise((resolveResult) => {
-    const child = spawn(command[0], command.slice(1), { cwd, env, shell: false, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
+    const child2 = spawn(command[0], command.slice(1), { cwd, env, shell: false, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
     let outputBytes = 0, error61, ended = false;
     const stdout = [], stderr = [];
     const kill = () => {
       try {
-        if (process.platform !== "win32" && child.pid)
-          process.kill(-child.pid, "SIGKILL");
+        if (process.platform !== "win32" && child2.pid)
+          process.kill(-child2.pid, "SIGKILL");
         else
-          child.kill("SIGKILL");
+          child2.kill("SIGKILL");
       } catch {
-        child.kill("SIGKILL");
+        child2.kill("SIGKILL");
       }
     };
     const timer = setTimeout(() => {
@@ -59559,8 +59807,8 @@ async function subprocess(command, cwd, env, input2, timeoutMs) {
       }
       target.push(chunk);
     };
-    child.stdout.on("data", capture2(stdout));
-    child.stderr.on("data", capture2(stderr));
+    child2.stdout.on("data", capture2(stdout));
+    child2.stderr.on("data", capture2(stderr));
     const finish = (code2) => {
       if (ended)
         return;
@@ -59568,13 +59816,13 @@ async function subprocess(command, cwd, env, input2, timeoutMs) {
       clearTimeout(timer);
       resolveResult({ exitCode: error61 === "LOCAL_RUN_TIMEOUT" ? 124 : error61 ? 1 : code2, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), ...error61 ? { error: error61 } : {} });
     };
-    child.on("error", () => {
+    child2.on("error", () => {
       error61 = "LOCAL_RUNTIME_START_FAILED";
       finish(127);
     });
-    child.on("close", (code2) => finish(code2 ?? 1));
-    child.stdin.on("error", () => {});
-    child.stdin.end(input2);
+    child2.on("close", (code2) => finish(code2 ?? 1));
+    child2.stdin.on("error", () => {});
+    child2.stdin.end(input2);
   });
 }
 var init_selected_run = __esm(() => {
@@ -60091,9 +60339,9 @@ function registerOperationTools(server) {
     }
   }, async ({ run_id, detail }) => {
     const { skillsCredentialOrReason: skillsCredentialOrReason2 } = await Promise.resolve().then(() => (init_fleet_credentials(), exports_fleet_credentials));
-    const { apiKey, apiOrigin, reason } = await skillsCredentialOrReason2();
+    const { apiKey, apiOrigin, reason: reason2 } = await skillsCredentialOrReason2();
     if (!apiKey) {
-      return mcpError("AUTH_REQUIRED", reason ?? "Remote run status requires API access. Run: skills auth login", ["skills auth login"]);
+      return mcpError("AUTH_REQUIRED", reason2 ?? "Remote run status requires API access. Run: skills auth login", ["skills auth login"]);
     }
     const localRun = findSkillRun(run_id);
     const remoteRunId = localRun?.remoteRunId || run_id;
@@ -60263,14 +60511,14 @@ var init_operation_tools = __esm(() => {
 
 // src/lib/feedback.ts
 import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync13 } from "fs";
-import { dirname as dirname21, join as join36 } from "path";
+import { dirname as dirname22, join as join36 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
   return join36(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname21(dbPath);
+  const dir = dirname22(dbPath);
   if (!existsSync17(dir))
     mkdirSync13(dir, { recursive: true });
   const db = new Database(dbPath);
@@ -60299,7 +60547,7 @@ function saveFeedback(input2) {
   const category = input2.category ?? "general";
   if (isApiMode()) {
     const path = join36(getDataDir(), "feedback.jsonl");
-    const dir = dirname21(path);
+    const dir = dirname22(path);
     if (!existsSync17(dir))
       mkdirSync13(dir, { recursive: true });
     appendFileSync(path, JSON.stringify({ message, category, email: input2.email ?? null, agent: input2.agent ?? null, version: input2.version ?? null, createdAt: new Date().toISOString() }) + `
@@ -60750,7 +60998,7 @@ var init_schedule_tools = __esm(() => {
 });
 
 // src/lib/native-storage.ts
-import { createHash as createHash22, createHmac } from "crypto";
+import { createHash as createHash23, createHmac } from "crypto";
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync15,
@@ -60759,7 +61007,7 @@ import {
   statSync as statSync11,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname22, join as join38, normalize as normalize4, relative as relative7, sep as sep9 } from "path";
+import { dirname as dirname23, join as join38, normalize as normalize4, relative as relative7, sep as sep9 } from "path";
 function resolveSkillsNativeStorageConfig(env = process.env) {
   assertNoRetiredModeEnvVars(env, {
     app: SKILLS_ENV_NAMESPACE,
@@ -60827,7 +61075,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash22("sha256").update(bytes).digest("hex"),
+        sha256: createHash23("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -61120,16 +61368,16 @@ var init_private_publication_customer = __esm(() => {
 
 // src/lib/private-publication-recovery.ts
 import { constants as constants14, closeSync as closeSync18, fsyncSync as fsyncSync5, fstatSync as fstatSync18, lstatSync as lstatSync22, mkdirSync as mkdirSync16, openSync as openSync18, readSync as readSync12, realpathSync as realpathSync11, renameSync as renameSync7, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname23, isAbsolute as isAbsolute18, join as join39, resolve as resolve20 } from "path";
+import { dirname as dirname24, isAbsolute as isAbsolute20, join as join39, resolve as resolve22 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function safeDirectory(directory2) {
-  if (!isAbsolute18(directory2) || directory2 !== resolve20(directory2) || realpathSync11(directory2) !== directory2)
+  if (!isAbsolute20(directory2) || directory2 !== resolve22(directory2) || realpathSync11(directory2) !== directory2)
     return fail2();
-  for (let path = directory2;; path = dirname23(path)) {
+  for (let path = directory2;; path = dirname24(path)) {
     const stat3 = lstatSync22(path);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       return fail2();
-    if (path === dirname23(path))
+    if (path === dirname24(path))
       break;
   }
   const own2 = lstatSync22(directory2);
@@ -61261,11 +61509,11 @@ async function preparePrivatePublication(client, sourceDirectory, recoveryDirect
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute18(recoveryDirectory) || resolve20(recoveryDirectory) !== recoveryDirectory || realpathSync11(dirname23(recoveryDirectory)) !== dirname23(recoveryDirectory))
+  if (!isAbsolute20(recoveryDirectory) || resolve22(recoveryDirectory) !== recoveryDirectory || realpathSync11(dirname24(recoveryDirectory)) !== dirname24(recoveryDirectory))
     return fail2();
   mkdirSync16(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync18(dirname23(recoveryDirectory), constants14.O_RDONLY | constants14.O_NOFOLLOW);
+  const parent = openSync18(dirname24(recoveryDirectory), constants14.O_RDONLY | constants14.O_NOFOLLOW);
   try {
     fsyncSync5(parent);
   } finally {
@@ -61362,10 +61610,10 @@ var init_private_publication_recovery = __esm(() => {
 });
 
 // src/mcp/private-publication-tools.ts
-import { isAbsolute as isAbsolute19 } from "path";
+import { isAbsolute as isAbsolute21 } from "path";
 function registerPrivatePublicationTools(server) {
   const uuid9 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
-  const directory2 = exports_external.string().max(4096).refine(isAbsolute19, "Use an absolute local directory");
+  const directory2 = exports_external.string().max(4096).refine(isAbsolute21, "Use an absolute local directory");
   const verification2 = { email: exports_external.string().email().max(254), code: exports_external.string().regex(/^\d{6}$/), userId: uuid9, membershipId: uuid9, recoveryDirectory: directory2 };
   const description = "Manage a private source publication using fresh workspace-bound verification and a host-local recovery directory. Publishing requires explicit UUID current-version comparison and upload consent. Resume reuses immutable saved bytes and intent; an uncertain PUT is finalized for server verification, never uploaded twice. Sessions and signed URLs are not returned or persisted. Private execution is unavailable. Host request history may contain the supplied verification code.";
   const handler = (action) => async (value) => {
@@ -61777,8 +62025,8 @@ var WSContext = class {
   }
   url;
   protocol;
-  close(code2, reason) {
-    this.#init.close(code2, reason);
+  close(code2, reason2) {
+    this.#init.close(code2, reason2);
   }
 }, defineWebSocketHelper = (handler) => {
   return (...args) => {
@@ -62058,9 +62306,9 @@ var RequestError, nonJoinedHeaders, validHeaderName, isHttpWhitespace = (code2)
 }, normalizeAbortError = (request2, incoming) => {
   if (incoming.errored)
     return incoming.errored;
-  const reason = request2[abortReasonKey];
-  if (reason !== undefined)
-    return reason instanceof Error ? reason : new Error(String(reason));
+  const reason2 = request2[abortReasonKey];
+  if (reason2 !== undefined)
+    return reason2 instanceof Error ? reason2 : new Error(String(reason2));
   return /* @__PURE__ */ new Error("Client connection prematurely closed.");
 }, readBodyDirect = (request2) => {
   if (request2[bodyBufferKey])
@@ -62077,7 +62325,7 @@ var RequestError, nonJoinedHeaders, validHeaderName, isHttpWhitespace = (code2)
     request2[bodyBufferKey] = buffered;
     return Promise.resolve(buffered);
   }
-  const promise3 = new Promise((resolve21, reject) => {
+  const promise3 = new Promise((resolve23, reject) => {
     const chunks = [];
     let settled = false;
     const finish = (callback) => {
@@ -62099,7 +62347,7 @@ var RequestError, nonJoinedHeaders, validHeaderName, isHttpWhitespace = (code2)
           reject(error61 ?? normalizeAbortError(request2, incoming));
         else {
           request2[bodyBufferKey] = recovered;
-          resolve21(recovered);
+          resolve23(recovered);
         }
       });
       return true;
@@ -62111,7 +62359,7 @@ var RequestError, nonJoinedHeaders, validHeaderName, isHttpWhitespace = (code2)
       finish(() => {
         const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
         request2[bodyBufferKey] = buffer;
-        resolve21(buffer);
+        resolve23(buffer);
       });
     };
     const onError = (error61) => {
@@ -62385,7 +62633,7 @@ var RequestError, nonJoinedHeaders, validHeaderName, isHttpWhitespace = (code2)
         });
         if (!chunk) {
           if (i === 1) {
-            await new Promise((resolve21) => setTimeout(resolve21));
+            await new Promise((resolve23) => setTimeout(resolve23));
             maxReadCount = 3;
             continue;
           }
@@ -62686,12 +62934,12 @@ var init_dist2 = __esm(() => {
     get headers() {
       return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
     },
-    [abortRequest](reason) {
+    [abortRequest](reason2) {
       if (this[abortReasonKey] === undefined)
-        this[abortReasonKey] = reason;
+        this[abortReasonKey] = reason2;
       const abortController = this[abortControllerKey];
       if (abortController && !abortController.signal.aborted)
-        abortController.abort(reason);
+        abortController.abort(reason2);
     },
     [getAbortController]() {
       this[abortControllerKey] ||= new AbortController;
@@ -63015,8 +63263,8 @@ var init_dist2 = __esm(() => {
       ws.on("message", bufferMessage);
       const ctx = {
         binaryType: "arraybuffer",
-        close(code2, reason) {
-          ws.close(code2, reason);
+        close(code2, reason2) {
+          ws.close(code2, reason2);
         },
         protocol: ws.protocol,
         raw: ws,
@@ -63048,11 +63296,11 @@ var init_dist2 = __esm(() => {
       ws.on("message", (data, isBinary) => {
         handleMessage(data, isBinary);
       });
-      ws.on("close", (code2, reason) => {
+      ws.on("close", (code2, reason2) => {
         try {
           events2?.onClose?.(new CloseEvent("close", {
             code: code2,
-            reason: reason.toString()
+            reason: reason2.toString()
           }), ctx);
         } catch (e2) {
           (options?.onError ?? console.error)(e2);
@@ -63615,9 +63863,9 @@ data:
       const initRequest = messages.find((m) => isInitializeRequest(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
       if (this._enableJsonResponse) {
-        return new Promise((resolve21) => {
+        return new Promise((resolve23) => {
           this._streamMapping.set(streamId, {
-            resolveJson: resolve21,
+            resolveJson: resolve23,
             cleanup: () => {
               this._streamMapping.delete(streamId);
             }
@@ -63986,19 +64234,19 @@ async function connectMcpForNode() {
   return { server: server2, transport };
 }
 function readBody(req) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve23, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve21(undefined);
+        resolve23(undefined);
         return;
       }
       try {
-        resolve21(JSON.parse(raw));
+        resolve23(JSON.parse(raw));
       } catch {
-        resolve21(undefined);
+        resolve23(undefined);
       }
     });
     req.on("error", reject);
@@ -64040,9 +64288,9 @@ async function startSkillsMcpHttpServer(options = {}) {
       }
     }
   });
-  await new Promise((resolve21, reject) => {
+  await new Promise((resolve23, reject) => {
     httpServer.once("error", reject);
-    httpServer.listen(port, hostname4, () => resolve21());
+    httpServer.listen(port, hostname4, () => resolve23());
   });
   const address = httpServer.address();
   const listenPort = typeof address === "object" && address ? address.port : port;