@hasna/skills 0.10.50 → 0.10.52

package/dist/index.js

@@ -5267,8 +5267,8 @@ var require_cst_visit = __commonJS((exports) => {
   visit.REMOVE = REMOVE;
   visit.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
@@ -5278,8 +5278,8 @@ var require_cst_visit = __commonJS((exports) => {
   };
   visit.parentCollection = (cst, path) => {
     const parent = visit.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");
@@ -5288,11 +5288,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)
@@ -5302,7 +5302,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);
       }
     }
@@ -5728,9 +5728,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 {
@@ -7262,7 +7262,7 @@ import {
   statSync as statSync11,
   writeFileSync as writeFileSync9
 } from "fs";
-import { basename as basename12, dirname as dirname21, isAbsolute as isAbsolute20, join as join34, normalize as normalize4, relative as relative7, resolve as resolve20, sep as sep10 } from "path";
+import { basename as basename13, dirname as dirname22, isAbsolute as isAbsolute22, join as join34, normalize as normalize4, relative as relative7, resolve as resolve22, sep as sep10 } from "path";
 
 // src/lib/registry-data/index.ts
 var SKILLS = [];
@@ -8922,7 +8922,7 @@ var NATIVE_SKILL_ROOTS = [
 // src/lib/authoring-path.ts
 import { lstatSync as lstatSync26, realpathSync as realpathSync12 } from "fs";
 import { homedir as homedir6 } from "os";
-import { basename as basename11, dirname as dirname20, join as join33, resolve as resolve19, sep as sep9 } from "path";
+import { basename as basename12, dirname as dirname21, join as join33, resolve as resolve21, sep as sep9 } from "path";
 
 // src/lib/agent-adapters.ts
 var INTEGRATION_AGENTS = ["claude", "codex", "gemini", "opencode", "cursor", "hermes", "sumi"];
@@ -9126,6 +9126,10 @@ function parse(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 parse(text);
+}
 var BOOLEAN_PREFERENCES = new Set([
   "autoScrollEnabled",
   "axScreenReader",
@@ -9379,7 +9383,222 @@ function upgradeSumiSettingsWitness(previous, reviewedSettingsPath) {
 }
 
 // src/lib/agent-policy-limits.ts
-import { basename as basename3, isAbsolute as isAbsolute3, join as join7, resolve as resolve3, sep as sep2 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4, sep as sep2 } from "path";
+
+// src/lib/codex-native-compatibility.ts
+var 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"]
+};
+function supportsCodexNativeCapability(version, capability) {
+  return typeof version === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version) && MEASURED_CODEX_CAPABILITIES[version].includes(capability);
+}
+var SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version) => supportsCodexNativeCapability(version, "hooks")));
+
+// src/lib/claude-marketplace-entry-witness.ts
+import { createHash as createHash4 } from "crypto";
+import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
+var CLAUDE_MARKETPLACE_ENTRY_HASH_MODE = "claude-marketplace-entry-v1";
+var DOMAIN = "hasna.skills.claude-marketplace-entry.v1\x00";
+var PATH_CHARACTERS = 4096;
+var NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function need2(value, reason) {
+  if (!value)
+    throw new Error(`Claude marketplace entry witness ${reason}`);
+}
+var bounded = (key) => key.length > 64 ? `${key.slice(0, 64)}...` : key;
+var quote = (text) => JSON.stringify(text).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+var child = (path, key) => path + (/^[A-Za-z0-9_$-]{1,64}$/.test(key) ? `.${key}` : `[${JSON.stringify(bounded(key))}]`);
+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(object, allowed, selector, path) {
+  for (const [key] of object.entries)
+    if (!allowed.has(key))
+      unknownKey(selector, path, key);
+}
+var reason = (error) => String(error?.message ?? error).replace(/^Claude settings witness /, "");
+var MARKETPLACE_KEYS = new Set(["$schema", "name", "owner", "plugins", "description", "version", "metadata", "forceRemoveDeletedPlugins", "allowCrossMarketplaceDependenciesOn", "renames"]);
+var MARKETPLACE_METADATA_KEYS = new Set(["description", "version", "pluginRoot"]);
+var 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"
+]);
+var ENTRY_OMITTED_KEYS = new Set(["$schema", "description", "version", "author", "homepage", "repository", "license", "keywords", "category", "tags", "displayName", "metadata"]);
+var EXPERIMENTAL_KEYS = new Set(["themes", "monitors", "evals"]);
+var 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"]
+});
+var field = (object, key) => object.entries.find(([name]) => name === key)?.[1];
+var isString = (value) => value?.kind === "string";
+var isBoolean = (value) => value?.kind === "literal" && (value.value === "true" || value.value === "false");
+var stringArray = (value) => value?.kind === "array" && value.items.every(isString);
+var stringObject = (value) => value?.kind === "object" && value.entries.every(([, item]) => isString(item));
+function claudeMarketplaceEntrySourceValid(source) {
+  const path = source?.path;
+  return typeof path === "string" && path.length > 0 && path.length <= PATH_CHARACTERS && !/[\x00-\x1f\x7f]/.test(path) && isAbsolute3(path) && resolve3(path) === path && basename3(path) === "marketplace.json" && basename3(dirname4(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 (error) {
+    throw new Error(`Claude marketplace entry witness cannot parse marketplace.json: ${reason(error)}`);
+  }
+  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 createHash4("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 (error) {
+    throw new Error(`Claude marketplace entry witness cannot read marketplace.json: ${reason(error)}`);
+  }
+  return { path, hashMode: CLAUDE_MARKETPLACE_ENTRY_HASH_MODE, marketplace, plugin, sha256: hashClaudeMarketplaceEntry(text, { marketplace, plugin }) };
+}
+
+// src/lib/agent-policy-limits.ts
 var 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 });
 function object(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -9433,7 +9652,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(isAbsolute3(control.pluginParent) && resolve3(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
+      requireBound(isAbsolute4(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)
@@ -9445,16 +9664,24 @@ function assertAgentPolicyCollections(policy) {
     }
   if (bridge.codexInactivePlugins !== undefined) {
     const controls = array(bridge.codexInactivePlugins, 4096), ids = new Set;
-    requireBound(controls.length === 0 || object(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 || object(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(object(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) && isAbsolute3(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) && isAbsolute4(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(record(bridge.discoveryExecutables, AGENT_POLICY_LIMITS.agents))) {
+      requireBound(agent === "gemini" && object(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) && isAbsolute4(path) && resolve4(path) === path);
+      }
+    }
   if (bridge.disabledBuiltins !== undefined)
     for (const builtin of array(bridge.disabledBuiltins, AGENT_POLICY_LIMITS.builtinNames)) {
       requireBound(object(builtin));
@@ -9480,11 +9707,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(isAbsolute3(root) && resolve3(root) === root);
+        requireBound(isAbsolute4(root) && resolve4(root) === root);
       }
       for (const parent of parents2) {
         text(parent);
-        requireBound(isAbsolute3(parent) && resolve3(parent) === parent);
+        requireBound(isAbsolute4(parent) && resolve4(parent) === parent);
       }
       for (const directory of array(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
         requireBound(object(directory));
@@ -9497,14 +9724,14 @@ function assertAgentPolicyCollections(policy) {
     }
     if (value.codexInstallationInputs !== undefined) {
       const proof = record(value.codexInstallationInputs, 4), inputs = array(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 && object(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 && object(bridge.codexPluginSkillReview) && bridge.codexPluginSkillReview.version === proof.version && bridge.codexPluginSkillReview.catalogSha256 === proof.catalogSha256);
       for (const input of inputs) {
         requireBound(object(input) && Object.keys(input).every((key) => ["pluginId", "namespace", "pluginParent", "sourceRoot", "sourceSha256"].includes(key)));
         text(input.pluginId, 1024);
         text(input.namespace, 64);
         text(input.pluginParent);
         text(input.sourceRoot);
-        requireBound(!ids.has(input.pluginId) && [input.pluginParent, input.sourceRoot].every((path) => isAbsolute3(path) && resolve3(path) === path) && typeof input.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input.sourceSha256));
+        requireBound(!ids.has(input.pluginId) && [input.pluginParent, input.sourceRoot].every((path) => isAbsolute4(path) && resolve4(path) === path) && typeof input.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input.sourceSha256));
         ids.add(input.pluginId);
       }
       if (proof.directories !== undefined)
@@ -9521,17 +9748,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) && isAbsolute3(source.path) && resolve3(source.path) === source.path && source.path.endsWith(join7(sep2, ".claude-plugin", "plugin.json")) && source.managedPlugins === undefined);
+        requireBound(agent === "claude" && value.agent === "claude" && ["automatic", "reviewed"].includes(value.method) && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve4(source.path) === source.path && source.path.endsWith(join7(sep2, ".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) && isAbsolute3(source.path) && resolve3(source.path) === source.path && basename3(source.path) === "sumi.json");
+        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve4(source.path) === source.path && basename4(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) && isAbsolute3(source.path) && resolve3(source.path) === source.path && basename3(source.path) === "config.toml");
+        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve4(source.path) === source.path && basename4(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) && isAbsolute3(source.path) && resolve3(source.path) === source.path && basename3(source.path) === "settings.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve4(source.path) === source.path && basename4(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) && isAbsolute3(source.path) && resolve3(source.path) === source.path && basename3(source.path) === "known_marketplaces.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve4(source.path) === source.path && basename4(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 = array(source.managedPlugins, 64);
@@ -9546,8 +9775,8 @@ function assertAgentPolicyCollections(policy) {
       if (source.format !== undefined)
         requireBound(["json", "toml", "yaml"].includes(source.format));
       if (source.fields !== undefined)
-        for (const field of array(source.fields, AGENT_POLICY_LIMITS.fields))
-          text(field, 256);
+        for (const field2 of array(source.fields, AGENT_POLICY_LIMITS.fields))
+          text(field2, 256);
     }
     if (value.directories !== undefined)
       for (const directory of array(value.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
@@ -9562,9 +9791,9 @@ function assertAgentPolicyCollections(policy) {
 }
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import { lstatSync as lstatSync25, readFileSync as readFileSync20, readdirSync as readdirSync10, realpathSync as realpathSync11 } from "fs";
-import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute19, join as join32, resolve as resolve18, sep as sep8 } from "path";
+import { basename as basename11, dirname as dirname20, isAbsolute as isAbsolute21, join as join32, resolve as resolve20, sep as sep8 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
 
 // node_modules/yaml/dist/index.js
@@ -9614,7 +9843,7 @@ var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
 // src/lib/agent-hermes.ts
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join8, resolve as resolve4 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute5, join as join8, resolve as resolve5 } from "path";
 import { lstatSync as lstatSync4, readFileSync as readFileSync6, opendirSync } from "fs";
 var HERMES_OPT_OUT = ".no-bundled-skills";
 var EVENTS = ["pre_llm_call", "pre_tool_call"];
@@ -9652,7 +9881,7 @@ function quoted(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function hermesHookDefinitions(supervisor) {
-  if (!isAbsolute4(supervisor.runtime) || !isAbsolute4(supervisor.path))
+  if (!isAbsolute5(supervisor.runtime) || !isAbsolute5(supervisor.path))
     throw new Error("Expected absolute Hermes supervisor paths");
   const entry = (event) => ({ command: `${quoted(supervisor.runtime)} ${quoted(supervisor.path)} --event ${event}`, timeout: 15, ...event === "pre_tool_call" ? { fail_closed: true } : {} });
   return { pre_llm_call: entry("pre_llm_call"), pre_tool_call: entry("pre_tool_call") };
@@ -9688,16 +9917,16 @@ 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 && (!isAbsolute4(selected) || resolve4(selected) !== join8(resolve4(home), ".hermes")))
+  if (selected && (!isAbsolute5(selected) || resolve5(selected) !== join8(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");
 }
 function read(path) {
-  for (let current = path;; current = dirname4(current)) {
+  for (let current = path;; current = dirname5(current)) {
     if (lstatSync4(current, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("NATIVE_SKILL_DRIFT: symlink Hermes protection input");
-    if (dirname4(current) === current)
+    if (dirname5(current) === current)
       break;
   }
   const stat = lstatSync4(path, { throwIfNoEntry: false });
@@ -9711,7 +9940,7 @@ function assertHermesProtection(home, config, command, profile, supervisor) {
   assertHermesEnvironment(home);
   if (read(join8(home, ".hermes", HERMES_OPT_OUT)) === null)
     throw new Error("NATIVE_SKILL_DRIFT: Hermes bundled skill reseeding is not disabled; run skills hook install");
-  if (!supervisor || !isAbsolute4(supervisor.path) || supervisor.runtime !== process.execPath || read(supervisor.path) !== renderHermesSupervisor(command, profile))
+  if (!supervisor || !isAbsolute5(supervisor.path) || supervisor.runtime !== process.execPath || read(supervisor.path) !== renderHermesSupervisor(command, profile))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes owned supervisor changed; run skills hook install");
   const raw = read(join8(home, ".hermes/shell-hooks-allowlist.json"));
   let trust;
@@ -9737,10 +9966,10 @@ function assertHermesProtection(home, config, command, profile, supervisor) {
 }
 function assertNoHermesLegacyShadow(root) {
   let entries = 0;
-  for (let cursor = resolve4(root);; cursor = dirname4(cursor)) {
+  for (let cursor = resolve5(root);; cursor = dirname5(cursor)) {
     if (lstatSync4(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("NATIVE_SKILL_DRIFT: symlink Hermes legacy discovery root");
-    if (dirname4(cursor) === cursor)
+    if (dirname5(cursor) === cursor)
       break;
   }
   function scan(path, depth) {
@@ -9761,10 +9990,10 @@ function assertNoHermesLegacyShadow(root) {
     const hasDescriptor = Boolean(lstatSync4(join8(path, "SKILL.md"), { throwIfNoEntry: false }));
     const directory = opendirSync(path);
     try {
-      for (let child = directory.readSync();child; child = directory.readSync()) {
-        if (hasDescriptor && ["references", "templates", "assets", "scripts"].includes(child.name))
+      for (let child2 = directory.readSync();child2; child2 = directory.readSync()) {
+        if (hasDescriptor && ["references", "templates", "assets", "scripts"].includes(child2.name))
           continue;
-        scan(join8(path, child.name), depth + 1);
+        scan(join8(path, child2.name), depth + 1);
       }
     } finally {
       directory.closeSync();
@@ -9821,18 +10050,18 @@ if (failed) process.exitCode = 2;
 }
 
 // src/lib/agent-discovery-directories.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { lstatSync as lstatSync5, opendirSync as opendirSync2 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute5, join as join9, resolve as resolve5 } from "path";
-function need2(value, message) {
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join9, 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 && isAbsolute5(path) && resolve5(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
-  for (let cursor = path;; cursor = dirname5(cursor)) {
-    need2(!lstatSync5(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
-    if (dirname5(cursor) === cursor)
+  need3(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute6(path) && resolve6(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
+  for (let cursor = path;; cursor = dirname6(cursor)) {
+    need3(!lstatSync5(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
+    if (dirname6(cursor) === cursor)
       break;
   }
 }
@@ -9846,45 +10075,45 @@ function capture(path, budget2, excludedRoots, omittedRoots = [], rows) {
   const root = lstatSync5(path, { throwIfNoEntry: false });
   if (!root)
     return { path, sha256: null };
-  need2(root.isDirectory(), "Unsupported native discovery directory input");
-  const hash = createHash4("sha256");
+  need3(root.isDirectory(), "Unsupported native discovery directory input");
+  const hash = createHash5("sha256");
   function walk(current, relative2, before, depth) {
-    need2(depth <= 64, "Native discovery directory depth limit exceeded");
+    need3(depth <= 64, "Native discovery directory depth limit exceeded");
     const names = [], directory = opendirSync2(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 = join9(current, name), childRelative = relative2 ? `${relative2}/${name}` : name;
-      if (omittedRoots.includes(child))
+      const child2 = join9(current, name), childRelative = relative2 ? `${relative2}/${name}` : name;
+      if (omittedRoots.includes(child2))
         continue;
-      need2(child.length <= AGENT_POLICY_LIMITS.pathCharacters, "Native discovery directory path limit exceeded");
-      const stat = lstatSync5(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 = lstatSync5(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");
       hash.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, lstatSync5(current, { throwIfNoEntry: false })), "Native discovery directory changed while reading");
+    need3(same(before, lstatSync5(current, { throwIfNoEntry: false })), "Native discovery directory changed while reading");
   }
   walk(path, "", root, 0);
   safe(path);
   return { path, sha256: hash.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 };
@@ -9894,62 +10123,62 @@ 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 hash = createHash4("sha256");
+    need3(Array.isArray(directory.entries), "Missing reviewed directory membership inventory");
+    const hash = createHash5("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] && !isAbsolute5(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] && !isAbsolute6(value[0]) && !value[0].split("/").some((part) => !part || part === "." || part === "..") && ["file", "directory"].includes(value[1]) && row === JSON.stringify(value) + `
 `, "Invalid reviewed directory member");
       hash.update(row);
       const path = join9(directory.path, value[0]);
       if (!omittedRoots.some((root) => path === root || path.startsWith(root + "/")))
         kept.push(row);
     }
-    need2(directory.sha256 === null ? directory.entries.length === 0 : hash.digest("hex") === directory.sha256, "Reviewed directory inventory does not match its fingerprint");
+    need3(directory.sha256 === null ? directory.entries.length === 0 : hash.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 : createHash4("sha256").update(kept.join("")).digest("hex") };
+    return { path: directory.path, sha256: absent || directory.sha256 === null ? null : createHash5("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}`);
 }
 
 // src/lib/agent-discovery-bytes.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, lstatSync as lstatSync6, openSync as openSync2, readSync as readSync2 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute6, resolve as resolve6 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute7, resolve as resolve7 } from "path";
 function discoveryByteBudget() {
   return { remaining: AGENT_POLICY_LIMITS.discoveryRawTotalBytes };
 }
 function safe2(path) {
-  if (typeof path !== "string" || !isAbsolute6(path) || path !== resolve6(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
+  if (typeof path !== "string" || !isAbsolute7(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 = dirname6(cursor)) {
+  for (let cursor = path;; cursor = dirname7(cursor)) {
     if (lstatSync6(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("Refusing symlink raw discovery input");
-    if (dirname6(cursor) === cursor)
+    if (dirname7(cursor) === cursor)
       break;
   }
 }
@@ -9968,7 +10197,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 createHash5("sha256").update(text2).digest("hex");
+    return createHash6("sha256").update(text2).digest("hex");
   }
   const initial = lstatSync6(path, { throwIfNoEntry: false });
   if (!initial)
@@ -9982,7 +10211,7 @@ function hashRawDiscoveryFile(path, budget2, changes) {
     const opened = fstatSync2(fd);
     if (!opened.isFile() || !same2(initial, opened))
       throw new Error("Raw discovery input changed during open");
-    const hash = createHash5("sha256"), buffer = Buffer.alloc(64 * 1024);
+    const hash = createHash6("sha256"), buffer = Buffer.alloc(64 * 1024);
     let bytes = 0;
     while (true) {
       const count = readSync2(fd, buffer, 0, Math.min(buffer.length, AGENT_POLICY_LIMITS.discoveryRawSourceBytes - bytes + 1), null);
@@ -10005,9 +10234,9 @@ function hashRawDiscoveryFile(path, budget2, changes) {
 }
 
 // src/lib/agent-discovery-path-bytes.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { lstatSync as lstatSync7, readlinkSync } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute7, join as join10, parse as parse2, resolve as resolve7, sep as sep3 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute8, join as join10, parse as parse2, resolve as resolve8, sep as sep3 } from "path";
 function identity2(stat, mutable = false) {
   return {
     dev: String(stat.dev),
@@ -10018,12 +10247,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" || !isAbsolute7(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" || !isAbsolute8(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 = parse2(path).root, pending = path.slice(cursor.length).split(sep3);
   function record2(path2, row) {
@@ -10048,7 +10277,7 @@ function trace(path) {
     if (!component || component === ".")
       continue;
     if (component === "..") {
-      cursor = dirname7(cursor);
+      cursor = dirname8(cursor);
       continue;
     }
     const candidate = join10(cursor, component);
@@ -10068,11 +10297,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");
       record2(candidate, { type: "link", target, ...identity2(stat, true) });
-      if (isAbsolute7(target)) {
+      if (isAbsolute8(target)) {
         cursor = parse2(target).root;
         root();
       }
-      const remainder = isAbsolute7(target) ? target.slice(parse2(target).root.length) : target;
+      const remainder = isAbsolute8(target) ? target.slice(parse2(target).root.length) : target;
       pending = [...remainder.split(sep3), ...pending];
       if (pending.length + steps > AGENT_POLICY_LIMITS.discoveryPathSteps)
         throw new Error("Discovery path step limit exceeded");
@@ -10115,15 +10344,15 @@ 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 createHash6("sha256").update(JSON.stringify({ version: 1, path, rows: before.rows, content })).digest("hex");
+  return createHash7("sha256").update(JSON.stringify({ version: 1, path, rows: before.rows, content })).digest("hex");
 }
 
 // src/lib/claude-plugin-manifest-witness.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 var CLAUDE_PLUGIN_MANIFEST_LIMITS = Object.freeze({ bytes: 1024 * 1024, depth: 32, nodes: 65536, stringCharacters: 16384 });
-function requireValue(value, reason) {
+function requireValue(value, reason2) {
   if (!value)
-    throw new Error("Claude plugin manifest " + reason);
+    throw new Error("Claude plugin manifest " + reason2);
 }
 function parse3(text2) {
   requireValue(Buffer.byteLength(text2, "utf8") <= CLAUDE_PLUGIN_MANIFEST_LIMITS.bytes, "exceeds its byte limit");
@@ -10199,7 +10428,7 @@ function parse3(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")
@@ -10207,19 +10436,19 @@ 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(",") + "}";
 }
 var DESCRIPTIVE_FIELDS = new Set(["description", "version", "author", "homepage", "repository", "license", "keywords"]);
-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) {
@@ -10244,10 +10473,10 @@ function hashClaudePluginManifest(text2) {
   const manifest = parse3(text2);
   validateDescriptiveFields(manifest);
   const discovery = { kind: "object", entries: manifest.entries.filter(([key]) => !DESCRIPTIVE_FIELDS.has(key)) };
-  return createHash7("sha256").update(canonical3(discovery)).digest("hex");
+  return createHash8("sha256").update(canonical4(discovery)).digest("hex");
 }
 function projectReviewedClaudePluginManifest(text2, reviewedSha256) {
-  if (!/^[a-f0-9]{64}$/.test(reviewedSha256) || createHash7("sha256").update(text2).digest("hex") !== reviewedSha256) {
+  if (!/^[a-f0-9]{64}$/.test(reviewedSha256) || createHash8("sha256").update(text2).digest("hex") !== reviewedSha256) {
     throw new Error("Reviewed Claude plugin manifest changed before semantic projection");
   }
   return hashClaudePluginManifest(text2);
@@ -10255,22 +10484,22 @@ function projectReviewedClaudePluginManifest(text2, reviewedSha256) {
 
 // src/lib/plugin-discovery.ts
 import { closeSync as closeSync13, constants as constants13, fstatSync as fstatSync13, lstatSync as lstatSync23, openSync as openSync13, opendirSync as opendirSync5, readSync as readSync10 } from "fs";
-import { basename as basename8, dirname as dirname17, isAbsolute as isAbsolute17, join as join31, resolve as resolve16 } from "path";
+import { basename as basename9, dirname as dirname18, isAbsolute as isAbsolute19, join as join31, resolve as resolve18 } from "path";
 
 // src/lib/plugin-admission.ts
 import { homedir as homedir5 } from "os";
-import { isAbsolute as isAbsolute16, join as join30, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute18, join as join30, resolve as resolve17 } from "path";
 
 // src/lib/selection-cache.ts
-import { createHash as createHash9, randomUUID } from "crypto";
+import { createHash as createHash10, randomUUID } from "crypto";
 import { spawnSync } from "child_process";
 import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, fsyncSync, linkSync, lstatSync as lstatSync8, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync8, readlinkSync as readlinkSync2, readSync as readSync3, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname8, join as join12, parse as parse4, resolve as resolve8 } from "path";
+import { dirname as dirname9, join as join12, parse as parse4, resolve as resolve9 } from "path";
 import { isDeepStrictEqual } from "util";
 
 // src/lib/skill-bundle.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
 import { join as join11, relative as relative2 } from "path";
 import { createGunzip } from "zlib";
@@ -10425,7 +10654,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash8("sha256").update(bytes).digest("hex");
+  return createHash9("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -10621,12 +10850,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;
 }
@@ -10656,7 +10885,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;
@@ -10671,7 +10907,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;
         check();
       }
@@ -10808,8 +11044,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);
@@ -10900,8 +11136,8 @@ function profileSelectionSnapshot(selections) {
 // src/lib/selection-cache.ts
 class SkillSelectionError extends Error {
   code;
-  constructor(code, message) {
-    super(message);
+  constructor(code, message, options) {
+    super(message, options);
     this.code = code;
     this.name = "SkillSelectionError";
   }
@@ -10909,14 +11145,14 @@ class SkillSelectionError extends Error {
 var MAX_CACHED_PROFILE_AGE_MS = 24 * 60 * 60 * 1000;
 var SELECTION_LOCK_FILE = "selection.lock.json";
 function selectionCacheRoot(options = {}) {
-  return resolve8(options.cacheDir ?? join12(getDataDirReadOnly(), "selection-cache"));
+  return resolve9(options.cacheDir ?? join12(getDataDirReadOnly(), "selection-cache"));
 }
 function selectionKey(selection) {
   validateSelection(selection);
   return hash([selection.authority, selection.workspaceId, selection.slug, selection.version, selection.bundleDigest]);
 }
 function hash(value) {
-  return createHash9("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash10("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()) {
@@ -10956,7 +11192,7 @@ function selectionBundlePath(selection, options = {}) {
   return join12(selectionCacheRoot(options), "objects", hash(selection.authority), hash(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
 }
 function assertRegularPath(path, createParents = false) {
-  const absolute = resolve8(path);
+  const absolute = resolve9(path);
   const root = parse4(absolute).root;
   let cursor = root;
   const segments = absolute.slice(root.length).split("/");
@@ -11013,7 +11249,7 @@ function writeSelectionJson(path, value) {
 }
 function atomicWrite(path, bytes, mode, durable = false) {
   assertRegularPath(path, true);
-  const temporary = join12(dirname8(path), `.selection-${randomUUID()}.tmp`);
+  const temporary = join12(dirname9(path), `.selection-${randomUUID()}.tmp`);
   try {
     const fd = openSync3(temporary, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW, mode);
     try {
@@ -11025,7 +11261,7 @@ function atomicWrite(path, bytes, mode, durable = false) {
     }
     renameSync(temporary, path);
     if (durable)
-      syncDirectory(dirname8(path));
+      syncDirectory(dirname9(path));
   } finally {
     try {
       unlinkSync(temporary);
@@ -11035,8 +11271,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 {
@@ -11048,10 +11284,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;
 }
@@ -11157,7 +11393,7 @@ function assertFreshCachedProfile(receipt, options = {}) {
   }
 }
 function projectSelectionLockPath(projectDir) {
-  return join12(resolve8(projectDir), ".skills", SELECTION_LOCK_FILE);
+  return join12(resolve9(projectDir), ".skills", SELECTION_LOCK_FILE);
 }
 function readProjectSelection(projectDir) {
   const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
@@ -11316,13 +11552,13 @@ function publishSessionLock(path, marker) {
     fsyncSync(fd);
     linkSync(stagingPath, path);
     published = true;
-    syncDirectory(dirname8(path));
+    syncDirectory(dirname9(path));
     const staged = lstatSync8(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(dirname8(path));
+    syncDirectory(dirname9(path));
     handedOff = true;
     return { path, stagingPath, fd, dev: stat.dev, ino: stat.ino };
   } finally {
@@ -11367,14 +11603,14 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     writeFileSync3(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
 `);
     fsyncSync(guardFd);
-    const cacheOptions = { cacheDir: dirname8(dirname8(lock.path)) };
+    const cacheOptions = { cacheDir: dirname9(dirname9(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 = join12(dirname8(dirname8(lock.path)), "session-lock-recoveries", randomUUID());
+    const directory = join12(dirname9(dirname9(lock.path)), "session-lock-recoveries", randomUUID());
     const archivePath = join12(directory, "original.write-lock");
     const recordPath = join12(directory, "recovery.json");
     assertRegularPath(archivePath, true);
@@ -11391,7 +11627,7 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     })}
 `));
     syncDirectory(directory);
-    syncDirectory(dirname8(directory));
+    syncDirectory(dirname9(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;
@@ -11406,7 +11642,7 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
         archivedPaths.push(publicationPath);
       }
       syncDirectory(directory);
-      syncDirectory(dirname8(lock.path));
+      syncDirectory(dirname9(lock.path));
       for (const path of archivedPaths) {
         const before = lstatSync8(path, { throwIfNoEntry: false });
         const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
@@ -11576,7 +11812,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
     archiveBytes(receiptPath, Buffer.from(`${JSON.stringify(receipt)}
 `));
     syncDirectory(directory);
-    syncDirectory(dirname8(directory));
+    syncDirectory(dirname9(directory));
     syncDirectory(selectionCacheRoot(options));
     if (sha256Hex(readRegularFile(archivePath, MAX_PROFILE_DOCUMENT_BYTES)) !== before.sha256 || !sameSnapshot(readSkillSessionSnapshot(replacement.sessionId, options), expected)) {
       throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The session or its preservation archive changed before replacement; retained evidence must be reviewed.");
@@ -11596,7 +11832,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.50",
+  version: "0.10.52",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -11733,12 +11969,12 @@ import { spawnSync as spawnSync2 } from "child_process";
 import { closeSync as closeSync22, fstatSync as fstatSync22, openSync as openSync22, readFileSync as readFileSync22 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW2, O_NONBLOCK as O_NONBLOCK2, O_RDONLY as O_RDONLY2 } from "constants";
 import { hostname as osHostname } from "os";
-import { isAbsolute as isAbsolute8, join as join22 } from "path";
+import { isAbsolute as isAbsolute9, join as join22 } from "path";
 import { createRequire } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { closeSync as closeSync4, fstatSync as fstatSync4, lstatSync as lstatSync9, openSync as openSync4, readFileSync as readFileSync9, realpathSync as realpathSync2, statSync as statSync6 } from "fs";
 import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
-import { basename as basename4, dirname as dirname9, join as join13, relative as relative3, sep as sep4 } from "path";
+import { basename as basename5, dirname as dirname10, join as join13, relative as relative3, sep as sep4 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function envToken(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -11844,9 +12080,9 @@ function entryPoint(directory) {
   return pathToFileURL(file).href;
 }
 function resolveInstalledSecrets(parentUrl) {
-  let directory = dirname9(fileURLToPath(parentUrl));
+  let directory = dirname10(fileURLToPath(parentUrl));
   for (;; ) {
-    if (basename4(directory) !== "node_modules") {
+    if (basename5(directory) !== "node_modules") {
       const candidate = join13(directory, "node_modules", PACKAGE);
       let absent = false;
       try {
@@ -11859,7 +12095,7 @@ function resolveInstalledSecrets(parentUrl) {
       if (!absent)
         return entryPoint(candidate);
     }
-    const parent = dirname9(directory);
+    const parent = dirname10(directory);
     if (parent === directory)
       throw new Error("Secrets SDK is not installed for this consumer");
     directory = parent;
@@ -11879,8 +12115,8 @@ class CredentialResolutionError extends Error {
 
 class CredentialFileUnsafeError 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;
   }
@@ -11906,7 +12142,7 @@ function homeDir(env) {
 }
 function absoluteOverride(env, key) {
   const value = env[key]?.trim();
-  return value && isAbsolute8(value) ? value : null;
+  return value && isAbsolute9(value) ? value : null;
 }
 function hasnaHomeDir(env) {
   const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
@@ -11952,9 +12188,9 @@ function parseEnvFile(text2) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
       continue;
     let value = withoutExport.slice(equals + 1).trim();
-    const quote = value[0];
-    if (quote === '"' || quote === "'") {
-      if (value.length < 2 || !value.endsWith(quote)) {
+    const quote2 = value[0];
+    if (quote2 === '"' || quote2 === "'") {
+      if (value.length < 2 || !value.endsWith(quote2)) {
         unusable.add(key);
         continue;
       }
@@ -11978,8 +12214,8 @@ function configFileReadsCoherent(before, after) {
   return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
 }
 function readAppConfigFile(path) {
-  const unsafe = (reason) => {
-    throw new CredentialFileUnsafeError(path, reason);
+  const unsafe = (reason2) => {
+    throw new CredentialFileUnsafeError(path, reason2);
   };
   let fd = -1;
   try {
@@ -12175,8 +12411,8 @@ function readKeychainItem(name, env, kind, options) {
   try {
     result = run(["find-generic-password", "-a", account, "-s", service, "-w"]);
   } catch (error) {
-    const reason = keychainFailureHint(error instanceof Error ? error.message : String(error));
-    throw new CredentialResolutionError(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 = keychainFailureHint(error instanceof Error ? error.message : String(error));
+    throw new CredentialResolutionError(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_STATUS)
     return null;
@@ -12994,7 +13230,7 @@ class MissingSkillsFleetError extends Error {
 }
 
 // src/lib/remote-files.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 var MAX_REMOTE_FILE_BYTES = 64 * 1024 * 1024;
 function describeRemoteFiles(files) {
   if (files.length > 10)
@@ -13012,7 +13248,7 @@ function describeRemoteFiles(files) {
   });
 }
 function sha256(bytes) {
-  return createHash10("sha256").update(bytes).digest("hex");
+  return createHash11("sha256").update(bytes).digest("hex");
 }
 async function readBoundedResponse(response, maximum, signal) {
   if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > MAX_REMOTE_FILE_BYTES)
@@ -13070,6 +13306,10 @@ function identifier(value) {
 function invalid() {
   throw new Error("The Skills API returned an invalid profile response");
 }
+function unavailable(error, message) {
+  const name = error?.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 (!object3(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();
@@ -13117,8 +13357,8 @@ class HttpProfileClient {
           ...init.headers
         }
       });
-    } catch {
-      throw new SkillSelectionError("SKILLS_API_UNAVAILABLE", "Unable to reach the configured Skills API");
+    } catch (error) {
+      throw unavailable(error, "Unable to reach the configured Skills API");
     }
     if (!response.ok) {
       response.body?.cancel().catch(() => {});
@@ -13135,7 +13375,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 (error) {
+      if (this.signal?.aborted)
+        throw unavailable(this.signal.reason ?? error, "The Skills API response was cut short");
       invalid();
     }
   }
@@ -13222,17 +13464,17 @@ import { constants as constants5, closeSync as closeSync6, fstatSync as fstatSyn
 import { join as join14 } from "path";
 
 // 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 {}
     }
   };
@@ -13431,20 +13673,20 @@ import { join as join28 } from "path";
 // src/lib/codex-corpus-write.ts
 import { KernelLock } from "@hasna/contracts/kernel-lock";
 import { execFileSync } from "child_process";
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { accessSync, constants as constants6, lstatSync as lstatSync12, readFileSync as readFileSync11, realpathSync as realpathSync3, statSync as statSync7 } from "fs";
-import { basename as basename5, delimiter, dirname as dirname10, isAbsolute as isAbsolute9, join as join15, relative as relative4, resolve as resolve9, sep as sep5 } from "path";
+import { basename as basename6, delimiter, dirname as dirname11, isAbsolute as isAbsolute10, join as join15, relative as relative4, resolve as resolve10, sep as sep5 } from "path";
 var KEY = ".native-corpus-admission";
 var fail = () => {
   throw new Error("CODEX_CORPUS_ADMISSION_REQUIRED: verified native admission and its existing shared lock are required");
 };
 function physicalTarget(path) {
   const suffix = [];
-  for (let cursor = path;; cursor = dirname10(cursor)) {
+  for (let cursor = path;; cursor = dirname11(cursor)) {
     try {
       return join15(realpathSync3(cursor), ...suffix);
     } catch (error) {
-      if (error.code !== "ENOENT" || cursor === dirname10(cursor))
+      if (error.code !== "ENOENT" || cursor === dirname11(cursor))
         throw error;
       try {
         if (lstatSync12(cursor).isSymbolicLink())
@@ -13453,14 +13695,14 @@ function physicalTarget(path) {
         if (statError.code !== "ENOENT")
           throw statError;
       }
-      suffix.unshift(basename5(cursor));
+      suffix.unshift(basename6(cursor));
     }
   }
 }
 function codexCorpusRootForPath(path) {
-  const target = resolve9(path), physical = physicalTarget(target);
+  const target = resolve10(path), physical = physicalTarget(target);
   const selected = process.env.CODEX_HOME;
-  const selectedRoots = selected && isAbsolute9(selected) ? [resolve9(selected), physicalTarget(resolve9(selected))] : [];
+  const selectedRoots = selected && isAbsolute10(selected) ? [resolve10(selected), physicalTarget(resolve10(selected))] : [];
   const classify = (candidate) => {
     const checked = (root2) => {
       if (candidate === root2 || candidate === join15(root2, `${KEY}.flock-v1`))
@@ -13469,10 +13711,10 @@ function codexCorpusRootForPath(path) {
     };
     for (const root2 of selectedRoots) {
       const distance = relative4(root2, candidate);
-      if (distance === "" || !distance.startsWith(`..${sep5}`) && distance !== ".." && !isAbsolute9(distance))
+      if (distance === "" || !distance.startsWith(`..${sep5}`) && distance !== ".." && !isAbsolute10(distance))
         return checked(root2);
     }
-    for (let cursor = candidate;cursor !== dirname10(cursor); cursor = dirname10(cursor)) {
+    for (let cursor = candidate;cursor !== dirname11(cursor); cursor = dirname11(cursor)) {
       if (cursor.endsWith(`${sep5}.codex`))
         return checked(cursor);
     }
@@ -13498,10 +13740,10 @@ function executable(options) {
   if (typeof command !== "string" || !command || command.includes("\x00") || options.codexSha256 !== undefined && !/^[a-f0-9]{64}$/.test(options.codexSha256))
     return fail();
   let found;
-  if (isAbsolute9(command))
+  if (isAbsolute10(command))
     found = command;
   else if (!command.includes(sep5)) {
-    found = (process.env.PATH ?? "").split(delimiter).filter(isAbsolute9).map((dir) => join15(dir, command)).find((candidate) => {
+    found = (process.env.PATH ?? "").split(delimiter).filter(isAbsolute10).map((dir) => join15(dir, command)).find((candidate) => {
       try {
         accessSync(candidate, constants6.X_OK);
         return true;
@@ -13515,7 +13757,7 @@ function executable(options) {
   const path = realpathSync3(found), initial = statSync7(path, { bigint: true });
   if (!initial.isFile() || (initial.mode & 0o022n) !== 0n || (initial.mode & 0o111n) === 0n || initial.uid !== BigInt(process.getuid()) && initial.uid !== 0n)
     return fail();
-  const hash2 = () => createHash11("sha256").update(readFileSync11(path)).digest("hex");
+  const hash2 = () => createHash12("sha256").update(readFileSync11(path)).digest("hex");
   const digest = hash2();
   if (options.codexSha256 && digest !== options.codexSha256)
     return fail();
@@ -13539,7 +13781,7 @@ function acquireCodexCorpusWrite(roots, options) {
     }
   };
   try {
-    if (roots.some((root) => typeof root !== "string" || !isAbsolute9(root) || root.includes("\x00")))
+    if (roots.some((root) => typeof root !== "string" || !isAbsolute10(root) || root.includes("\x00")))
       fail();
     const inputs = [...new Set(roots)].map((input) => ({ input, root: realpathSync3(input) })).sort((a, b) => a.root.localeCompare(b.root));
     for (const { input, root } of inputs) {
@@ -13609,10 +13851,10 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename7, dirname as dirname15, join as join25 } from "path";
+import { basename as basename8, dirname as dirname16, join as join25 } from "path";
 
 // src/lib/codex-plugin-skill-controls.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 
 // src/lib/codex-local-mcp-controls.ts
 function isCodexLocalStdioMcpServer(name, server) {
@@ -13681,43 +13923,24 @@ function isCodexLocalStdioMcpServer(name, server) {
 }
 
 // src/lib/codex-plugin-skill-controls.ts
-import { basename as basename6, dirname as dirname11, join as join17, relative as relative5, resolve as resolve10, sep as sep6 } from "path";
+import { basename as basename7, dirname as dirname12, join as join17, relative as relative5, resolve as resolve11, sep as sep6 } from "path";
 import { lstatSync as lstatSync13, readdirSync as readdirSync6, readlinkSync as readlinkSync3, realpathSync as realpathSync6 } from "fs";
 
-// src/lib/codex-native-compatibility.ts
-var 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"]
-};
-function supportsCodexNativeCapability(version, capability) {
-  return typeof version === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version) && MEASURED_CODEX_CAPABILITIES[version].includes(capability);
-}
-var SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version) => supportsCodexNativeCapability(version, "hooks")));
-
 // src/lib/codex-native-skill-catalog.ts
 import { realpathSync as realpathSync5 } from "fs";
-import { isAbsolute as isAbsolute11, normalize as normalize2 } from "path";
+import { isAbsolute as isAbsolute12, normalize as normalize2 } from "path";
 
 // src/lib/codex-hook-rpc.ts
 import { join as join16 } from "path";
 import { execFile, spawn } from "child_process";
 import { realpathSync as realpathSync4, statSync as statSync8 } from "fs";
-import { isAbsolute as isAbsolute10 } from "path";
+import { isAbsolute as isAbsolute11 } from "path";
 import { promisify } from "util";
 async function connectCodexHookRpc(options) {
   const timeoutMs = options.timeoutMs ?? 20000;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 20000)
     throw new Error("CODEX_HOOK_TRUST_INVALID_TIMEOUT");
-  const found = isAbsolute10(options.command) ? options.command : Bun.which(options.command, { PATH: process.env.PATH });
+  const found = isAbsolute11(options.command) ? options.command : Bun.which(options.command, { PATH: process.env.PATH });
   if (!found)
     throw new Error("CODEX_HOOK_TRUST_NATIVE_UNAVAILABLE: install Codex or pass --codex-command");
   const binary = realpathSync4(found), stat = statSync8(binary);
@@ -13741,16 +13964,16 @@ async function connectCodexHookRpc(options) {
   else
     env.CODEX_HOME = options.codexHome;
   const corpusLease = acquireCodexCorpusWrite([options.codexHome ?? join16(options.home, ".codex")], { codexCommand: binary });
-  const child = spawn(binary, ["app-server", "--strict-config", "--stdio"], {
+  const child2 = spawn(binary, ["app-server", "--strict-config", "--stdio"], {
     cwd: options.home,
     env,
     stdio: ["pipe", "pipe", "pipe"]
   });
   let childClosed = false;
-  const actualClose = new Promise((resolve10) => child.once("close", () => {
+  const actualClose = new Promise((resolve11) => child2.once("close", () => {
     childClosed = true;
     corpusLease.close();
-    resolve10();
+    resolve11();
   }));
   const pending = new Map;
   let nextId = 1, buffer = Buffer.alloc(0), stopped = false, diagnosticBytes = 0;
@@ -13762,20 +13985,20 @@ async function connectCodexHookRpc(options) {
     }
     pending.clear();
   };
-  child.on("error", fail2);
-  child.on("exit", fail2);
-  child.stdin.on("error", fail2);
-  child.stderr.on("data", (bytes) => {
+  child2.on("error", fail2);
+  child2.on("exit", fail2);
+  child2.stdin.on("error", fail2);
+  child2.stderr.on("data", (bytes) => {
     diagnosticBytes += bytes.length;
     if (diagnosticBytes > 2 * 1024 * 1024) {
       fail2();
-      child.kill();
+      child2.kill();
     }
   });
-  child.stdout.on("data", (bytes) => {
+  child2.stdout.on("data", (bytes) => {
     if (buffer.length + bytes.length > 8 * 1024 * 1024) {
       fail2();
-      child.kill();
+      child2.kill();
       return;
     }
     buffer = Buffer.concat([buffer, bytes]);
@@ -13790,12 +14013,12 @@ async function connectCodexHookRpc(options) {
         value = JSON.parse(line.toString("utf8"));
       } catch {
         fail2();
-        child.kill();
+        child2.kill();
         return;
       }
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         fail2();
-        child.kill();
+        child2.kill();
         return;
       }
       const waiting = pending.get(value.id);
@@ -13811,29 +14034,29 @@ async function connectCodexHookRpc(options) {
   });
   const rpc = {
     version,
-    processId: child.pid,
+    processId: child2.pid,
     request(method, params) {
       if (stopped)
         return Promise.reject(new Error("CODEX_HOOK_TRUST_NATIVE_RPC_CLOSED"));
-      return new Promise((resolve10, reject) => {
+      return new Promise((resolve11, reject) => {
         const id = nextId++;
         const timer = setTimeout(() => {
           fail2();
-          child.kill();
+          child2.kill();
         }, timeoutMs);
-        pending.set(id, { resolve: resolve10, reject, timer });
-        child.stdin.write(JSON.stringify({ id, method, params }) + `
+        pending.set(id, { resolve: resolve11, reject, timer });
+        child2.stdin.write(JSON.stringify({ id, method, params }) + `
 `);
       });
     },
     async close() {
       fail2();
-      child.stdin.end();
+      child2.stdin.end();
       if (childClosed)
         return;
-      await new Promise((resolve10, reject) => {
+      await new Promise((resolve11, reject) => {
         const terminate = setTimeout(() => {
-          child.kill();
+          child2.kill();
         }, 1000);
         const deadline = setTimeout(() => {
           clearTimeout(terminate);
@@ -13842,7 +14065,7 @@ async function connectCodexHookRpc(options) {
         actualClose.then(() => {
           clearTimeout(terminate);
           clearTimeout(deadline);
-          resolve10();
+          resolve11();
         });
       });
     }
@@ -13852,7 +14075,7 @@ async function connectCodexHookRpc(options) {
     const nativeVersion = version.slice("codex-cli ".length);
     if (typeof initialized?.userAgent !== "string" || !(initialized.userAgent === `skills-native-hook-enrollment/${nativeVersion}` || initialized.userAgent.startsWith(`skills-native-hook-enrollment/${nativeVersion} `)))
       throw new Error("CODEX_HOOK_TRUST_NATIVE_VERSION_MISMATCH");
-    child.stdin.write(`{"method":"initialized"}
+    child2.stdin.write(`{"method":"initialized"}
 `);
     return rpc;
   } catch {
@@ -13876,7 +14099,7 @@ function refuse() {
 var object4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var scalar = (value, max) => typeof value === "string" && value.length > 0 && value.trim() === value && Buffer.byteLength(value, "utf8") <= max && !/[\u0000-\u001f\u007f]/u.test(value);
 var remotePluginIdentifier = (value) => typeof value === "string" && /^[A-Za-z0-9_~-]{1,1024}$/.test(value);
-var absolutePath2 = (value) => scalar(value, MAX_PATH_BYTES) && isAbsolute11(value);
+var absolutePath2 = (value) => scalar(value, MAX_PATH_BYTES) && isAbsolute12(value);
 function projectPluginSource(source) {
   if (!object4(source))
     return {};
@@ -14075,7 +14298,7 @@ function mcpControls(path, read2) {
 function isBundledCleanupHooks(root, namespace, value) {
   const object5 = (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 (basename6(dirname11(root)) !== namespace || basename6(dirname11(dirname11(root))) !== "openai-bundled")
+  if (basename7(dirname12(root)) !== namespace || basename7(dirname12(dirname12(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 || !object5(value) || !exactKeys(value, ["hooks"]) || !object5(value.hooks))
@@ -14109,7 +14332,7 @@ function rootControls(root, read2) {
   }
   if (!manifest || typeof manifest !== "object" || Array.isArray(manifest) || !identifier2(manifest.name))
     refuse2();
-  const cacheVersion = basename6(root), declaredVersion = manifest.version === undefined ? "" : typeof manifest.version === "string" ? manifest.version.trim() : null;
+  const cacheVersion = basename7(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))
     refuse2();
   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" || lstatSync13(join17(root, "hooks"), { throwIfNoEntry: false }))
@@ -14154,7 +14377,7 @@ function documentIdentity(document2, cache, read2) {
   }
   if (!front || typeof front !== "object" || !identifier2(front.name) || typeof front.description !== "string" || !front.description.trim())
     refuse2();
-  for (let root = dirname11(document2), depth = 0;root.startsWith(cache + sep6) && depth < 12; root = dirname11(root), depth++) {
+  for (let root = dirname12(document2), depth = 0;root.startsWith(cache + sep6) && depth < 12; root = dirname12(root), depth++) {
     const path = join17(root, ".codex-plugin", "plugin.json");
     if (!lstatSync13(path, { throwIfNoEntry: false }))
       continue;
@@ -14172,9 +14395,9 @@ function documentIdentity(document2, cache, read2) {
     if (!manifest || typeof manifest !== "object" || Array.isArray(manifest) || !identifier2(manifest.name))
       refuse2();
     const declaredVersion = manifest.version === undefined ? "" : typeof manifest.version === "string" ? manifest.version.trim() : null;
-    if (declaredVersion === null || (declaredVersion ? declaredVersion !== basename6(root) : basename6(root) !== CODEX_DEFAULT_AGENT_PLUGIN_VERSION))
+    if (declaredVersion === null || (declaredVersion ? declaredVersion !== basename7(root) : basename7(root) !== CODEX_DEFAULT_AGENT_PLUGIN_VERSION))
       refuse2();
-    return { name: `${manifest.name}:${front.name}`, namespace: manifest.name, pluginParent: dirname11(root), root };
+    return { name: `${manifest.name}:${front.name}`, namespace: manifest.name, pluginParent: dirname12(root), root };
   }
   refuse2();
 }
@@ -14203,13 +14426,13 @@ function classifyCodexPluginCacheDocument(document2, cache, read2) {
 function reviewedDisabledCodexPluginParent(cache, parent, controls, rules) {
   try {
     const parts = relative5(cache, parent).split(sep6), enrolled = controls.filter((control) => control.pluginParent === parent);
-    if (resolve10(parent) !== parent || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !enrolled.length || !Array.isArray(rules))
+    if (resolve11(parent) !== parent || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !enrolled.length || !Array.isArray(rules))
       return false;
-    for (let cursor = parent;; cursor = dirname11(cursor)) {
+    for (let cursor = parent;; cursor = dirname12(cursor)) {
       const stat = lstatSync13(cursor, { throwIfNoEntry: false });
       if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
         return false;
-      if (dirname11(cursor) === cursor)
+      if (dirname12(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 + sep6))) && rule.enabled !== false));
@@ -14222,14 +14445,14 @@ function absentDisabledCodexPluginParent(cache, parent, controls, rules) {
 }
 function reviewedRetiredCodexRoot(cache, root, controls, rules, read2, allowAbsent = false) {
   try {
-    const parent = dirname11(root), parts = relative5(cache, parent).split(sep6), 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))
+    const parent = dirname12(root), parts = relative5(cache, parent).split(sep6), enrolled = controls.filter((control) => control.pluginParent === parent);
+    if (resolve11(root) !== root || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !basename7(root) || basename7(root) === "latest" || !enrolled.length || !Array.isArray(rules))
       return false;
-    for (let cursor = root;; cursor = dirname11(cursor)) {
+    for (let cursor = root;; cursor = dirname12(cursor)) {
       const stat = lstatSync13(cursor, { throwIfNoEntry: false });
       if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
         return false;
-      if (dirname11(cursor) === cursor)
+      if (dirname12(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 + sep6))) && rule.enabled !== false)))
@@ -14276,8 +14499,8 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read2, rules)
       for (const name of names) {
         let root = join17(parent, name), stat = lstatSync13(root);
         if (stat.isSymbolicLink()) {
-          const target = resolve10(parent, readlinkSync3(root));
-          if (name !== "latest" || dirname11(target) !== parent || !lstatSync13(target).isDirectory() || realpathSync6(target) !== target)
+          const target = resolve11(parent, readlinkSync3(root));
+          if (name !== "latest" || dirname12(target) !== parent || !lstatSync13(target).isDirectory() || realpathSync6(target) !== target)
             return false;
           root = target;
           stat = lstatSync13(root);
@@ -14297,6 +14520,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read2, rules)
 function reviewCodexPluginControls(catalog, documents, cache, cwd, read2, rules, pluginSettings, plannedRules, denials = []) {
   if (!supportsCodexNativeCapability(catalog?.version, "qualified-skill-catalog") || catalog.cwd !== cwd)
     refuse2();
+  const installedPluginReview = supportsCodexNativeCapability(catalog.version, "installed-plugin-review");
   if (!Array.isArray(denials) || denials.length > 4096 || new Set(denials.map((item) => item?.path)).size !== denials.length || denials.some((item) => !item || Object.keys(item).sort().join(",") !== "name,path,sha256" || typeof item.name !== "string" || typeof item.path !== "string" || !/^[a-f0-9]{64}$/.test(item.sha256)))
     refuse2();
   const usedDenials = new Set;
@@ -14328,7 +14552,7 @@ function reviewCodexPluginControls(catalog, documents, cache, cwd, read2, rules,
     if (listed.length > 1)
       refuse2();
     const installed = installedPlugins.filter((plugin) => plugin.id === expectedPluginId && plugin.name === pluginName);
-    if (catalog.version === "codex-cli 0.160.0" && installed.length === 1 && installed[0].installed && installed[0].localVersion === basename6(located.root) && installed[0].sourceType === "local" && codexPluginSourceIsConfigControlled(installed[0])) {
+    if (installedPluginReview && installed.length === 1 && installed[0].installed && installed[0].localVersion === basename7(located.root) && installed[0].sourceType === "local" && codexPluginSourceIsConfigControlled(installed[0])) {
       const plugin = installed[0], input = { pluginId: expectedPluginId, namespace: located.namespace, pluginParent: located.pluginParent, sourceRoot: plugin.sourcePath, sourceSha256: plugin.sourceSha256 };
       if (input.sourceRoot !== located.root && !input.sourceRoot.startsWith(cache + sep6) && (lstatSync13(input.sourceRoot, { throwIfNoEntry: false }) || documents.some((path) => path.startsWith(input.sourceRoot + sep6)))) {
         if (skills.some((skill) => skill.path === input.sourceRoot || skill.path.startsWith(input.sourceRoot + sep6)) || !sourceInputUnchanged(input, cache, read2))
@@ -14337,7 +14561,7 @@ function reviewCodexPluginControls(catalog, documents, cache, cwd, read2, rules,
       }
     }
     const settings = pluginSettings && typeof pluginSettings === "object" && !Array.isArray(pluginSettings) ? pluginSettings : undefined;
-    if (catalog.version === "codex-cli 0.160.0" && !listed.length && !skills.some((skill) => skill.pluginId === expectedPluginId) && installed.length === 1 && installed[0].installed && !installed[0].enabled && codexPluginSourceIsConfigControlled(installed[0]) && settings && Object.hasOwn(settings, expectedPluginId) && settings[expectedPluginId]?.enabled === false) {
+    if (installedPluginReview && !listed.length && !skills.some((skill) => skill.pluginId === expectedPluginId) && installed.length === 1 && installed[0].installed && !installed[0].enabled && codexPluginSourceIsConfigControlled(installed[0]) && settings && Object.hasOwn(settings, expectedPluginId) && settings[expectedPluginId]?.enabled === false) {
       if (!Array.isArray(rules))
         refuse2();
       const exactPathDeny = rules.some((rule) => rule?.path === document2 && rule?.enabled === false);
@@ -14360,7 +14584,7 @@ function reviewCodexPluginControls(catalog, documents, cache, cwd, read2, rules,
         refuse2();
       const plugin = installed[0];
       if (plugin.localVersion !== null) {
-        if (plugin.localVersion !== basename6(dirname11(dirname11(dirname11(document2)))))
+        if (plugin.localVersion !== basename7(dirname12(dirname12(dirname12(document2)))))
           continue;
       } else {
         if (plugin.sourceType !== "remote" || !plugin.remotePluginId || !remoteInstallationMatches(parsed.pluginParent, plugin.remotePluginId, read2) || !lstatSync13(document2).isFile() || realpathSync6(document2) !== document2)
@@ -14370,12 +14594,12 @@ function reviewCodexPluginControls(catalog, documents, cache, cwd, read2, rules,
       const exactPathDeny = Array.isArray(rules) && rules.some((rule) => rule?.path === document2 && rule?.enabled === false);
       const nativeSkill = { name: parsed.name, path: document2, pluginId: expectedPluginId, enabled: true };
       const denial = denials.find((item) => item.path === document2);
-      const explicitDeny = denial !== undefined && remotePluginId !== undefined && catalog.version === "codex-cli 0.160.0" && denial.name === parsed.name && denial.sha256 === createHash12("sha256").update(read2(document2)).digest("hex") && Array.isArray(rules) && !rules.some((rule) => (rule?.path === document2 || typeof rule?.name === "string" && rule.name.trim() === parsed.name) && rule.enabled !== false) && Array.isArray(plannedRules) && plannedRules.some((rule) => rule?.path === document2 && rule.enabled === false);
+      const explicitDeny = denial !== undefined && remotePluginId !== undefined && installedPluginReview && denial.name === parsed.name && denial.sha256 === createHash13("sha256").update(read2(document2)).digest("hex") && Array.isArray(rules) && !rules.some((rule) => (rule?.path === document2 || typeof rule?.name === "string" && rule.name.trim() === parsed.name) && rule.enabled !== false) && Array.isArray(plannedRules) && plannedRules.some((rule) => rule?.path === document2 && rule.enabled === false);
       if (denial && !explicitDeny)
         refuse2();
       if (explicitDeny)
         usedDenials.add(document2);
-      const plannedPathDeny = catalog.version === "codex-cli 0.160.0" && remotePluginId !== undefined && Array.isArray(rules) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === parsed.name && rule.enabled === false) && !rules.some((rule) => (rule?.path === document2 || typeof rule?.name === "string" && rule.name.trim() === parsed.name) && rule.enabled !== false) && Array.isArray(plannedRules) && plannedRules.some((rule) => rule?.path === document2 && rule.enabled === false) && isCodexNativeSkillDisabled(nativeSkill, plannedRules);
+      const plannedPathDeny = installedPluginReview && remotePluginId !== undefined && Array.isArray(rules) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === parsed.name && rule.enabled === false) && !rules.some((rule) => (rule?.path === document2 || typeof rule?.name === "string" && rule.name.trim() === parsed.name) && rule.enabled !== false) && Array.isArray(plannedRules) && plannedRules.some((rule) => rule?.path === document2 && rule.enabled === false) && isCodexNativeSkillDisabled(nativeSkill, plannedRules);
       if (!explicitDeny && (!exactPathDeny && !plannedPathDeny || !isCodexNativeSkillDisabled(nativeSkill, rules)))
         refuse2();
     }
@@ -14391,7 +14615,7 @@ function reviewCodexPluginControls(catalog, documents, cache, cwd, read2, rules,
 function sourceInputUnchanged(input, cache, read2) {
   try {
     const parts = relative5(cache, input.pluginParent).split(sep6);
-    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== input.namespace || input.pluginId !== `${parts[1]}@${parts[0]}` || !codexPluginSourceIsConfigControlled({ id: input.pluginId, sourceType: "local", sourceSha256: input.sourceSha256 }) || input.sourceSha256 !== hashNativeJsonControls(JSON.stringify({ type: "local", path: input.sourceRoot })) || resolve10(input.sourceRoot) !== input.sourceRoot || !lstatSync13(input.sourceRoot).isDirectory() || realpathSync6(input.sourceRoot) !== input.sourceRoot || input.sourceRoot === cache || input.sourceRoot.startsWith(cache + sep6) || cache.startsWith(input.sourceRoot + sep6))
+    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== input.namespace || input.pluginId !== `${parts[1]}@${parts[0]}` || !codexPluginSourceIsConfigControlled({ id: input.pluginId, sourceType: "local", sourceSha256: input.sourceSha256 }) || input.sourceSha256 !== hashNativeJsonControls(JSON.stringify({ type: "local", path: input.sourceRoot })) || resolve11(input.sourceRoot) !== input.sourceRoot || !lstatSync13(input.sourceRoot).isDirectory() || realpathSync6(input.sourceRoot) !== input.sourceRoot || input.sourceRoot === cache || input.sourceRoot.startsWith(cache + sep6) || cache.startsWith(input.sourceRoot + sep6))
       return false;
     const path = join17(input.sourceRoot, ".codex-plugin/plugin.json"), stat = lstatSync13(path);
     if (!stat.isFile() || stat.size > 1024 * 1024 || realpathSync6(path) !== path)
@@ -14457,9 +14681,9 @@ enabled = false
 }
 
 // src/lib/codex-native-skill-policy.ts
-import { createHash as createHash13, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID2 } from "crypto";
 import { closeSync as closeSync7, constants as constants7, fstatSync as fstatSync7, fsyncSync as fsyncSync2, lstatSync as lstatSync14, mkdirSync as mkdirSync5, openSync as openSync7, readFileSync as readFileSync12, readSync as readSync5, readlinkSync as readlinkSync4, realpathSync as realpathSync7, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute12, join as join18, resolve as resolve11 } from "path";
+import { dirname as dirname13, isAbsolute as isAbsolute13, join as join18, resolve as resolve12 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 var CODEX_NATIVE_POLICY_CAPABILITY = "host-path-allowlist-v1";
 var CODEX_NATIVE_POLICY_RECEIPT_SCHEMA = "skills.codex-native-policy-acceptance/v1";
@@ -14482,9 +14706,9 @@ function refuse3(code, detail) {
   throw new Error(`${code}: ${detail}`);
 }
 var object5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-function boundedId(value, field) {
+function boundedId(value, field2) {
   if (typeof value !== "string" || !value || value.length > MAX_ENVELOPE_ID_LENGTH || value.trim() !== value || /[\u0000-\u001f\u007f]/.test(value))
-    refuse3("NATIVE_SKILL_POLICY_INVALID", `${field} must be a bounded non-empty string`);
+    refuse3("NATIVE_SKILL_POLICY_INVALID", `${field2} must be a bounded non-empty string`);
   return value;
 }
 function parseCodexNativePolicyTrust(value) {
@@ -14507,9 +14731,9 @@ function parseCodexNativeHookEnvelope(envelope, bridgeDocument) {
   if (!object5(value))
     refuse3("NATIVE_SKILL_POLICY_INVALID", "native_skill_policy must be an object");
   const keys = Object.keys(value);
-  for (const field of POLICY_FIELDS)
-    if (!Object.hasOwn(value, field))
-      refuse3("NATIVE_SKILL_POLICY_INVALID", `native_skill_policy.${field} is missing`);
+  for (const field2 of POLICY_FIELDS)
+    if (!Object.hasOwn(value, field2))
+      refuse3("NATIVE_SKILL_POLICY_INVALID", `native_skill_policy.${field2} is missing`);
   if (keys.length !== POLICY_FIELDS.length)
     refuse3("NATIVE_SKILL_POLICY_INVALID", "native_skill_policy carries unknown fields");
   if (value.capability !== CODEX_NATIVE_POLICY_CAPABILITY)
@@ -14573,19 +14797,19 @@ function readBounded(path, maximum, what) {
   }
 }
 function verifyCodexNativeBridgeDocument(path, expectedContent, expectedSha256) {
-  if (!isAbsolute12(path) || resolve11(path) !== path || !path.endsWith("/SKILL.md"))
+  if (!isAbsolute13(path) || resolve12(path) !== path || !path.endsWith("/SKILL.md"))
     refuse3("NATIVE_SKILL_POLICY_BRIDGE_UNVERIFIED", "the bridge document path is not an exact absolute SKILL.md path");
-  for (let cursor = path;; cursor = dirname12(cursor)) {
+  for (let cursor = path;; cursor = dirname13(cursor)) {
     const stat = lstatSync14(cursor, { throwIfNoEntry: false });
     if (!stat || stat.isSymbolicLink() || (cursor === path ? !stat.isFile() : !stat.isDirectory()))
       refuse3("NATIVE_SKILL_POLICY_BRIDGE_UNVERIFIED", `the bridge path has a missing, linked or unexpected component: ${cursor}`);
-    if (dirname12(cursor) === cursor)
+    if (dirname13(cursor) === cursor)
       break;
   }
   if (realpathSync7.native(path) !== path)
     refuse3("NATIVE_SKILL_POLICY_BRIDGE_UNVERIFIED", "the bridge document real path differs from its lexical path");
   const bytes = readBounded(path, MAX_BRIDGE_DOCUMENT_BYTES, "the bridge document");
-  const sha2562 = createHash13("sha256").update(bytes).digest("hex");
+  const sha2562 = createHash14("sha256").update(bytes).digest("hex");
   if (!bytes.equals(Buffer.from(expectedContent, "utf8")) || sha2562 !== expectedSha256)
     refuse3("NATIVE_SKILL_POLICY_BRIDGE_UNVERIFIED", "the bridge document bytes differ from the managed bridge");
   return { path, sha256: sha2562 };
@@ -14651,13 +14875,13 @@ function assertExecutableWitnessStat(stat, currentUid) {
   return { dev: String(stat.dev), ino: String(stat.ino), size: String(stat.size), mtimeNs: String(stat.mtimeNs), ctimeNs: String(stat.ctimeNs), uid: String(stat.uid) };
 }
 function executableWitness(path) {
-  if (!isAbsolute12(path) || resolve11(path) !== path)
+  if (!isAbsolute13(path) || resolve12(path) !== path)
     refuse3("NATIVE_SKILL_POLICY_PROCESS_UNBOUND", "the consumer executable path is not an exact absolute path");
-  for (let cursor = dirname12(path);; cursor = dirname12(cursor)) {
+  for (let cursor = dirname13(path);; cursor = dirname13(cursor)) {
     const stat2 = lstatSync14(cursor, { throwIfNoEntry: false });
     if (!stat2 || stat2.isSymbolicLink() || !stat2.isDirectory())
       refuse3("NATIVE_SKILL_POLICY_PROCESS_UNBOUND", `the consumer executable path has a missing, linked or unexpected component: ${cursor}`);
-    if (dirname12(cursor) === cursor)
+    if (dirname13(cursor) === cursor)
       break;
   }
   const stat = lstatSync14(path, { throwIfNoEntry: false, bigint: true });
@@ -14668,7 +14892,7 @@ function executableWitness(path) {
 var witnessKey = (path, witness) => JSON.stringify([path, witness.dev, witness.ino, witness.size, witness.mtimeNs, witness.ctimeNs, witness.uid]);
 var executableDigestMemory = new Map;
 function executableCachePath(dataDir2) {
-  return join18(resolve11(dataDir2), "agent-hooks", "codex-native-policy-executable-cache.json");
+  return join18(resolve12(dataDir2), "agent-hooks", "codex-native-policy-executable-cache.json");
 }
 var currentUid = () => process.getuid?.() ?? -1;
 function readTrustedCacheBytes(path, ownerUid) {
@@ -14713,16 +14937,16 @@ function readExecutableCache(dataDir2, ownerUid = currentUid()) {
     if (!object5(value) || value.schema !== CODEX_NATIVE_POLICY_EXECUTABLE_CACHE_SCHEMA || !Array.isArray(value.entries) || value.entries.length > 16)
       return [];
     const fields = ["path", "sha256", "dev", "ino", "size", "mtimeNs", "ctimeNs", "uid"];
-    return value.entries.filter((entry) => object5(entry) && Object.keys(entry).length === fields.length && fields.every((field) => typeof entry[field] === "string") && HEX_DIGEST.test(entry.sha256) && isAbsolute12(entry.path) && ["dev", "ino", "size", "mtimeNs", "ctimeNs", "uid"].every((field) => /^\d{1,30}$/.test(entry[field])));
+    return value.entries.filter((entry) => object5(entry) && Object.keys(entry).length === fields.length && fields.every((field2) => typeof entry[field2] === "string") && HEX_DIGEST.test(entry.sha256) && isAbsolute13(entry.path) && ["dev", "ino", "size", "mtimeNs", "ctimeNs", "uid"].every((field2) => /^\d{1,30}$/.test(entry[field2])));
   } catch {
     return [];
   }
 }
 function writeExecutableCache(dataDir2, entries) {
-  const path = executableCachePath(dataDir2), directory = dirname12(path), temporary = `${path}.skills-${randomUUID2()}`;
+  const path = executableCachePath(dataDir2), directory = dirname13(path), temporary = `${path}.skills-${randomUUID2()}`;
   let descriptor;
   try {
-    const parent = lstatSync14(dirname12(directory), { throwIfNoEntry: false });
+    const parent = lstatSync14(dirname13(directory), { throwIfNoEntry: false });
     if (!parent || parent.isSymbolicLink() || !parent.isDirectory())
       return;
     const existing = lstatSync14(directory, { throwIfNoEntry: false });
@@ -14790,16 +15014,16 @@ function verifyCodexNativeExecutable(inspector, processId, trust, cache = {}, ex
 }
 function assertOperatorTrustRoot(dataDir2) {
   const check = (path, what, required) => {
-    if (!isAbsolute12(path) || resolve11(path) !== path)
+    if (!isAbsolute13(path) || resolve12(path) !== path)
       refuse3("NATIVE_SKILL_POLICY_TRUST_INVALID", `${what} path is not an exact absolute path`);
-    for (let cursor = dirname12(path);; cursor = dirname12(cursor)) {
+    for (let cursor = dirname13(path);; cursor = dirname13(cursor)) {
       const stat2 = lstatSync14(cursor, { throwIfNoEntry: false });
       if (!stat2) {
         if (required)
           refuse3("NATIVE_SKILL_POLICY_TRUST_INVALID", `${what} has a missing path component: ${cursor}`);
       } else if (stat2.isSymbolicLink() || !stat2.isDirectory())
         refuse3("NATIVE_SKILL_POLICY_TRUST_INVALID", `${what} has a linked or unexpected path component: ${cursor}`);
-      if (dirname12(cursor) === cursor)
+      if (dirname13(cursor) === cursor)
         break;
     }
     const stat = lstatSync14(path, { throwIfNoEntry: false, bigint: true });
@@ -14829,9 +15053,9 @@ function assertOperatorTrustRoot(dataDir2) {
     if ((stat.mode & 0o022n) !== 0n)
       refuse3("NATIVE_SKILL_POLICY_TRUST_INVALID", `${what} is group- or world-writable`);
   };
-  checkDirectory(resolve11(dataDir2), "the Skills data directory", true);
-  checkDirectory(dirname12(executableCachePath(dataDir2)), "the agent-hooks directory", false);
-  check(join18(resolve11(dataDir2), "agent-policy.json"), "the managed policy", true);
+  checkDirectory(resolve12(dataDir2), "the Skills data directory", true);
+  checkDirectory(dirname13(executableCachePath(dataDir2)), "the agent-hooks directory", false);
+  check(join18(resolve12(dataDir2), "agent-policy.json"), "the managed policy", true);
   check(executableCachePath(dataDir2), "the executable identity cache", false);
 }
 function runCodexNativePolicyHelper(request) {
@@ -15002,12 +15226,12 @@ function defaultProcessInspector() {
   return { platform: process.platform, arch: process.arch, pid: process.pid, parentOf: () => null, startTime: () => null, executablePath: () => null };
 }
 function codexNativePolicyReceiptPath(dataDir2) {
-  return join18(resolve11(dataDir2), "agent-hooks", "codex-native-policy-acceptance.json");
+  return join18(resolve12(dataDir2), "agent-hooks", "codex-native-policy-acceptance.json");
 }
 function recordCodexNativePolicyAcceptance(dataDir2, verification, accepted) {
-  const path = codexNativePolicyReceiptPath(dataDir2), directory = dirname12(path);
+  const path = codexNativePolicyReceiptPath(dataDir2), directory = dirname13(path);
   const acceptedCache = accepted.map((entry) => ({ path: entry.path, treeSha256: entry.treeSha256 })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  if (acceptedCache.some((entry) => !isAbsolute12(entry.path) || !HEX_DIGEST.test(entry.treeSha256)) || new Set(acceptedCache.map((entry) => entry.path)).size !== acceptedCache.length)
+  if (acceptedCache.some((entry) => !isAbsolute13(entry.path) || !HEX_DIGEST.test(entry.treeSha256)) || new Set(acceptedCache.map((entry) => entry.path)).size !== acceptedCache.length)
     refuse3("NATIVE_SKILL_POLICY_RECEIPT_FAILED", "accepted cache entries must be unique absolute paths with tree digests");
   const value = {
     schema: CODEX_NATIVE_POLICY_RECEIPT_SCHEMA,
@@ -15053,11 +15277,11 @@ function recordCodexNativePolicyAcceptance(dataDir2, verification, accepted) {
 }
 
 // src/lib/codex-settings-witness-v1.ts
-import { createHash as createHash14 } from "crypto";
-var sha = (text2) => createHash14("sha256").update(text2).digest("hex");
+import { createHash as createHash15 } from "crypto";
+var sha = (text2) => createHash15("sha256").update(text2).digest("hex");
 var EFFORT = new Set(["none", "minimal", "low", "medium", "high", "xhigh"]);
 var VERBOSITY = new Set(["low", "medium", "high"]);
-function need3(value) {
+function need4(value) {
   if (!value)
     throw new Error("Invalid Codex settings witness");
 }
@@ -15072,14 +15296,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;
         }
@@ -15100,8 +15324,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")
@@ -15109,20 +15333,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 config;
   try {
@@ -15130,17 +15354,17 @@ function hashCodexSettingsReplacement(text2, budget2 = { remaining: 256 * 1024 *
   } catch {
     throw new Error("Invalid Codex settings witness");
   }
-  need3(config && typeof config === "object" && !Array.isArray(config));
+  need4(config && typeof config === "object" && !Array.isArray(config));
   if (Object.hasOwn(config, "model")) {
-    need3(typeof config.model === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(config.model));
+    need4(typeof config.model === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(config.model));
     delete config.model;
   }
   for (const [key, values] of [["model_reasoning_effort", EFFORT], ["model_verbosity", VERBOSITY]])
     if (Object.hasOwn(config, key)) {
-      need3(typeof config[key] === "string" && values.has(config[key]));
+      need4(typeof config[key] === "string" && values.has(config[key]));
       delete config[key];
     }
-  return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical4(config), numericTokens(text2)])}`);
+  return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical5(config), numericTokens(text2)])}`);
 }
 function captureCodexSettings(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const text2 = readNativeSettingsWitnessFile(path, budget2, "config.toml");
@@ -15211,15 +15435,15 @@ function projectRegularCodexMcp(config, source) {
 }
 
 // src/lib/codex-settings-witness.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
-var sha2 = (text2) => createHash15("sha256").update(text2).digest("hex");
+var sha2 = (text2) => createHash16("sha256").update(text2).digest("hex");
 var EFFORT2 = new Set(["none", "minimal", "low", "medium", "high", "xhigh"]);
 var VERBOSITY2 = new Set(["low", "medium", "high"]);
 var MODEL = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
 var CODEX_DISCOVERY_PROJECTION_FIELDS = ["plugins", "marketplaces", "skills"];
 var INFERENCE = ["model", "model_reasoning_effort", "model_verbosity"];
-function need4(value) {
+function need5(value) {
   if (!value)
     throw new Error("Invalid Codex settings witness");
 }
@@ -15240,14 +15464,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;
         }
@@ -15268,8 +15492,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")
@@ -15277,17 +15501,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 normalize3(config, version = 2) {
   if (isRecord3(config.hooks)) {
@@ -15329,15 +15553,15 @@ function inference(target, version) {
     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 (version >= 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];
     }
 }
@@ -15370,14 +15594,14 @@ function projectModelAvailabilityNux(config, 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;
@@ -15457,14 +15681,14 @@ function settingsDigest2(text2, version = 2) {
   } catch {
     throw new Error("Invalid Codex settings witness");
   }
-  need4(isRecord3(config));
+  need5(isRecord3(config));
   const mcp = version >= 3 ? projectRegularCodexMcp(config, text2) : { config, numericSource: text2 };
   const projected = version === 4 ? projectModelAvailabilityNux(mcp.config, mcp.numericSource) : mcp;
   normalize3(projected.config, version);
-  return sha2(`hasna.skills.codex-settings.v${version}\x00${JSON.stringify([canonical5(projected.config), numericTokens2(projected.numericSource)])}`);
+  return sha2(`hasna.skills.codex-settings.v${version}\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);
 }
@@ -15476,17 +15700,17 @@ function readCodexSettingsPreimage(path, budget2 = { remaining: 2 * 1024 * 1024
   return readNativeSettingsWitnessFile(path, budget2, "config.toml");
 }
 function upgradeCodexSettingsWitness(previous, reviewedSettingsPath) {
-  need4(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || previous.hashMode === "bytes" || previous.hashMode === "codex-settings-v1") && /^[a-f0-9]{64}$/.test(previous.sha256));
+  need5(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || previous.hashMode === "bytes" || previous.hashMode === "codex-settings-v1") && /^[a-f0-9]{64}$/.test(previous.sha256));
   const budget2 = { remaining: 2 * 1024 * 1024 };
   const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget2, "config.toml"), current = readNativeSettingsWitnessFile(previous.path, budget2, "config.toml");
-  need4((previous.hashMode === "codex-settings-v1" ? hashCodexSettingsReplacement(before) : sha2(before)) === previous.sha256);
+  need5((previous.hashMode === "codex-settings-v1" ? hashCodexSettingsReplacement(before) : sha2(before)) === previous.sha256);
   const sha2562 = settingsDigest2(current);
   if (settingsDigest2(before) !== sha2562)
     throw new Error("Codex non-preference settings changed; explicit discovery review required");
   return { path: previous.path, hashMode: "codex-settings-v2", sha256: sha2562 };
 }
 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);
 }
@@ -15494,18 +15718,18 @@ function captureCodexSettingsV3(path, budget2 = { remaining: 256 * 1024 * 1024 }
   return { path, hashMode: "codex-settings-v3", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 3) };
 }
 function upgradeCodexSettingsWitnessV3(previous, reviewedSettingsPath) {
-  need4(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || ["bytes", "codex-settings-v1", "codex-settings-v2"].includes(previous.hashMode)) && /^[a-f0-9]{64}$/.test(previous.sha256));
+  need5(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || ["bytes", "codex-settings-v1", "codex-settings-v2"].includes(previous.hashMode)) && /^[a-f0-9]{64}$/.test(previous.sha256));
   const budget2 = { remaining: 2 * 1024 * 1024 };
   const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget2, "config.toml"), current = readNativeSettingsWitnessFile(previous.path, budget2, "config.toml");
   const original = previous.hashMode === "codex-settings-v2" ? settingsDigest2(before) : previous.hashMode === "codex-settings-v1" ? hashCodexSettingsReplacement(before) : sha2(before);
-  need4(original === previous.sha256);
+  need5(original === previous.sha256);
   const sha2562 = settingsDigest2(current, 3);
   if (settingsDigest2(before, 3) !== sha2562)
     throw new Error("Codex settings outside the reviewed V3 contract changed; explicit discovery review required");
   return { path: previous.path, hashMode: "codex-settings-v3", sha256: sha2562 };
 }
 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);
 }
@@ -15513,11 +15737,11 @@ function captureCodexSettingsV4(path, budget2 = { remaining: 256 * 1024 * 1024 }
   return { path, hashMode: "codex-settings-v4", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 4) };
 }
 function upgradeCodexSettingsWitnessV4(previous, reviewedSettingsPath) {
-  need4(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || ["bytes", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3"].includes(previous.hashMode)) && /^[a-f0-9]{64}$/.test(previous.sha256));
+  need5(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || ["bytes", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3"].includes(previous.hashMode)) && /^[a-f0-9]{64}$/.test(previous.sha256));
   const budget2 = { remaining: 2 * 1024 * 1024 };
   const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget2, "config.toml"), current = readNativeSettingsWitnessFile(previous.path, budget2, "config.toml");
   const original = previous.hashMode === "codex-settings-v3" ? settingsDigest2(before, 3) : previous.hashMode === "codex-settings-v2" ? settingsDigest2(before, 2) : previous.hashMode === "codex-settings-v1" ? hashCodexSettingsReplacement(before) : sha2(before);
-  need4(original === previous.sha256);
+  need5(original === previous.sha256);
   const sha2562 = settingsDigest2(current, 4);
   if (settingsDigest2(before, 4) !== sha2562)
     throw new Error("Codex settings outside the reviewed V4 contract changed; explicit discovery review required");
@@ -15525,17 +15749,17 @@ function upgradeCodexSettingsWitnessV4(previous, reviewedSettingsPath) {
 }
 
 // src/lib/agent-integration.ts
-import { createHash as createHash19, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash20, randomUUID as randomUUID3 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual6 } from "util";
-import { existsSync as existsSync9, lstatSync as lstatSync20, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync15, readdirSync as readdirSync8, opendirSync as opendirSync3, readlinkSync as readlinkSync6, realpathSync as realpathSync10, renameSync as renameSync3, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync11, closeSync as closeSync11, fsyncSync as fsyncSync5, fstatSync as fstatSync11, readSync as readSync8, constants as constants11, linkSync as linkSync2 } from "fs";
-import { dirname as dirname14, join as join23, resolve as resolve13, relative as relative6, isAbsolute as isAbsolute14, sep as sep7 } from "path";
+import { existsSync as existsSync9, lstatSync as lstatSync20, statSync as statSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync15, readdirSync as readdirSync8, opendirSync as opendirSync3, readlinkSync as readlinkSync7, realpathSync as realpathSync10, renameSync as renameSync3, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, chmodSync, openSync as openSync11, closeSync as closeSync11, fsyncSync as fsyncSync5, fstatSync as fstatSync11, readSync as readSync8, constants as constants11, linkSync as linkSync2 } from "fs";
+import { dirname as dirname15, join as join23, resolve as resolve15, relative as relative6, isAbsolute as isAbsolute16, sep as sep7 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/managed-policy.ts
 import { closeSync as closeSync8, constants as constants8, fstatSync as fstatSync8, lstatSync as lstatSync15, openSync as openSync8, readSync as readSync6 } from "fs";
 import { join as join19 } 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)
@@ -15612,7 +15836,7 @@ function requiresCliSkillLoading(dataDir2 = getDataDirReadOnly()) {
 }
 
 // src/lib/agent-bridge.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { lstatSync as lstatSync16, readFileSync as readFileSync13, readdirSync as readdirSync7 } from "fs";
 import { join as join20 } from "path";
 var CLI_BRIDGE_NAME = "skills-cli";
@@ -15631,7 +15855,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.
 `;
-var CLI_BRIDGE_DIGEST = createHash16("sha256").update(markdown).digest("hex");
+var CLI_BRIDGE_DIGEST = createHash17("sha256").update(markdown).digest("hex");
 var 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)}
@@ -15660,29 +15884,29 @@ var CODEX_SKILL_CONFIG_SECTIONS = /^\[\[skills\.config\]\][^\n]*(?:\n(?!\s*\[)[^
 var codexPathConfigRefusal = () => new Error("Codex skill path controls require ordinary [[skills.config]] TOML tables or a native single-line inline array; preserve and review unsupported inline, dotted, or malformed definitions before running skills hook install");
 function splitTopLevel(value, delimiter2) {
   const result = [];
-  let start = 0, square = 0, curly = 0, quote = null, escaped = false;
+  let start = 0, square = 0, curly = 0, quote2 = null, escaped = false;
   for (let index = 0;index < value.length; index++) {
     const char = value[index];
-    if (quote === "double") {
+    if (quote2 === "double") {
       if (escaped)
         escaped = false;
       else if (char === "\\")
         escaped = true;
       else if (char === '"')
-        quote = null;
+        quote2 = null;
       continue;
     }
-    if (quote === "literal") {
+    if (quote2 === "literal") {
       if (char === "'")
-        quote = null;
+        quote2 = null;
       continue;
     }
     if (char === '"') {
-      quote = "double";
+      quote2 = "double";
       continue;
     }
     if (char === "'") {
-      quote = "literal";
+      quote2 = "literal";
       continue;
     }
     if (char === "[")
@@ -15700,7 +15924,7 @@ function splitTopLevel(value, delimiter2) {
       start = index + 1;
     }
   }
-  if (quote !== null || square !== 0 || curly !== 0)
+  if (quote2 !== null || square !== 0 || curly !== 0)
     return null;
   result.push(value.slice(start));
   return result;
@@ -15708,29 +15932,29 @@ function splitTopLevel(value, delimiter2) {
 function inlineArrayEnd(value) {
   if (!value.startsWith("["))
     return null;
-  let square = 0, curly = 0, quote = null, escaped = false;
+  let square = 0, curly = 0, quote2 = null, escaped = false;
   for (let index = 0;index < value.length; index++) {
     const char = value[index];
-    if (quote === "double") {
+    if (quote2 === "double") {
       if (escaped)
         escaped = false;
       else if (char === "\\")
         escaped = true;
       else if (char === '"')
-        quote = null;
+        quote2 = null;
       continue;
     }
-    if (quote === "literal") {
+    if (quote2 === "literal") {
       if (char === "'")
-        quote = null;
+        quote2 = null;
       continue;
     }
     if (char === '"') {
-      quote = "double";
+      quote2 = "double";
       continue;
     }
     if (char === "'") {
-      quote = "literal";
+      quote2 = "literal";
       continue;
     }
     if (char === "[")
@@ -15767,7 +15991,7 @@ function inlineRowsAsTables(value, newline) {
     const fields = splitTopLevel(row.slice(1, -1), ",");
     if (!fields)
       return null;
-    const lines = fields.map((field) => field.trim()).filter(Boolean);
+    const lines = fields.map((field2) => field2.trim()).filter(Boolean);
     if (lines.some((line) => !/^(?:path|name|enabled)\s*=/.test(line)))
       return null;
     const keys = lines.map((line) => line.slice(0, line.indexOf("=")).trim());
@@ -15792,27 +16016,27 @@ function normalizeCodexInlinePathConfig(text2) {
   const matches = [];
   for (const assignment of text2.matchAll(/^([ \t]*config[ \t]*=[ \t]*)(.*?)(\r?)$/gm)) {
     const rawValue = assignment[2].trimEnd();
-    let quote = null, escaped = false, comment = "";
+    let quote2 = null, escaped = false, comment = "";
     for (let index = 0;index < rawValue.length; index++) {
       const char = rawValue[index];
-      if (quote === "double") {
+      if (quote2 === "double") {
         if (escaped)
           escaped = false;
         else if (char === "\\")
           escaped = true;
         else if (char === '"')
-          quote = null;
+          quote2 = null;
         continue;
       }
-      if (quote === "literal") {
+      if (quote2 === "literal") {
         if (char === "'")
-          quote = null;
+          quote2 = null;
         continue;
       }
       if (char === '"')
-        quote = "double";
+        quote2 = "double";
       else if (char === "'")
-        quote = "literal";
+        quote2 = "literal";
       else if (char === "#") {
         comment = rawValue.slice(index);
         break;
@@ -15924,28 +16148,28 @@ function disableCodexBundledSkills(text2) {
 
 // src/lib/agent-sumi.ts
 import { existsSync as existsSync8, lstatSync as lstatSync17, realpathSync as realpathSync8 } from "fs";
-import { join as join21, resolve as resolve12 } from "path";
+import { join as join21, resolve as resolve13 } 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) => resolve12(value === "~" ? home : value.startsWith("~/") ? join21(home, value.slice(2)) : value);
+  const expand = (value) => resolve13(value === "~" ? home : value.startsWith("~/") ? join21(home, value.slice(2)) : value);
   const explicit = selected("SUMI_CONFIG_DIR");
   const xdg = selected("XDG_CONFIG_HOME");
   const custom = selected("SUMI_HOME");
-  const canonical6 = explicit ? expand(explicit) : xdg ? join21(expand(xdg), "sumi") : join21(custom ? expand(custom) : join21(home, ".hasna-internal/sumi"), "config");
+  const canonical7 = explicit ? expand(explicit) : xdg ? join21(expand(xdg), "sumi") : join21(custom ? expand(custom) : join21(home, ".hasna-internal/sumi"), "config");
   if (explicit || xdg || custom)
-    return canonical6;
+    return canonical7;
   const legacy = join21(home, ".config/sumi");
-  const a = lstatSync17(canonical6, { throwIfNoEntry: false }), b = lstatSync17(legacy, { throwIfNoEntry: false });
-  if (a && b && realpathSync8(canonical6) !== realpathSync8(legacy))
+  const a = lstatSync17(canonical7, { throwIfNoEntry: false }), b = lstatSync17(legacy, { throwIfNoEntry: false });
+  if (a && b && realpathSync8(canonical7) !== realpathSync8(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 = realpathSync8(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;
 }
@@ -16045,33 +16269,49 @@ var SUMI_SKILL_PERMISSIONS = [
 ];
 
 // src/lib/codex-hook-trust-files.ts
-import { closeSync as closeSync9, constants as constants9, fstatSync as fstatSync9, fsyncSync as fsyncSync3, lstatSync as lstatSync18, openSync as openSync9, readSync as readSync7, writeFileSync as writeFileSync5 } from "fs";
-import { createHash as createHash17 } from "crypto";
-import { dirname as dirname13 } from "path";
-function need5(value, code) {
+import { closeSync as closeSync9, constants as constants9, fstatSync as fstatSync9, fsyncSync as fsyncSync3, lstatSync as lstatSync18, openSync as openSync9, readlinkSync as readlinkSync5, readSync as readSync7, writeFileSync as writeFileSync5 } from "fs";
+import { createHash as createHash18 } from "crypto";
+import { dirname as dirname14, isAbsolute as isAbsolute14, resolve as resolve14 } from "path";
+function need6(value, code) {
   if (!value)
     throw new Error(`CODEX_HOOK_TRUST_${code}`);
 }
 var sameStat = (a, b) => ["dev", "ino", "uid", "nlink", "mode", "size", "mtimeNs", "ctimeNs"].every((key) => a[key] === b[key]);
+function trustedAncestorOwner(uid) {
+  return BigInt(uid) === 0n || BigInt(uid) === BigInt(process.getuid());
+}
 function safeParents(file) {
-  for (let p = dirname13(file);; p = dirname13(p)) {
+  for (let p = dirname14(file);; p = dirname14(p)) {
     const s = lstatSync18(p);
-    need5(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
-    need5((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
-    if (dirname13(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 (dirname14(p) === p)
       break;
   }
 }
+function directAliasTarget(link) {
+  const text2 = readlinkSync5(link), parts = text2.split("/");
+  let first = 0;
+  if (isAbsolute14(text2))
+    first = 1;
+  else
+    while (parts[first] === "..")
+      first++;
+  const names = parts.slice(first);
+  if (!names.length || names.some((part) => part === "" || part === "." || part === ".."))
+    return;
+  return resolve14(dirname14(link), text2);
+}
 function snapshot(file, privateFile = false, options = {}) {
   const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
   safeParents(file);
   const initial = lstatSync18(file, { 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 = openSync9(file, constants9.O_RDONLY | constants9.O_NOFOLLOW | constants9.O_NONBLOCK);
   try {
     const before = fstatSync9(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) {
@@ -16080,22 +16320,22 @@ function snapshot(file, privateFile = false, options = {}) {
         break;
       length += n2;
     }
-    need5(length === Number(before.size) && sameStat(before, fstatSync9(fd, { bigint: true })) && sameStat(before, lstatSync18(file, { bigint: true })), "INPUT_CHANGED");
+    need6(length === Number(before.size) && sameStat(before, fstatSync9(fd, { bigint: true })) && sameStat(before, lstatSync18(file, { bigint: true })), "INPUT_CHANGED");
     const content = bytes.subarray(0, length), text2 = new TextDecoder("utf-8", { fatal: true }).decode(content);
-    return { file, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash17("sha256").update(content).digest("hex") };
+    return { file, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash18("sha256").update(content).digest("hex") };
   } finally {
     closeSync9(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");
 }
 
 // src/cli/commands/runtime-launcher.ts
-import { createHash as createHash18 } from "crypto";
-import { closeSync as closeSync10, constants as constants10, fchmodSync, fstatSync as fstatSync10, fsyncSync as fsyncSync4, lstatSync as lstatSync19, openSync as openSync10, readFileSync as readFileSync14, readlinkSync as readlinkSync5, realpathSync as realpathSync9, symlinkSync, writeSync as writeSync2 } from "fs";
-import { isAbsolute as isAbsolute13 } from "path";
+import { createHash as createHash19 } from "crypto";
+import { closeSync as closeSync10, constants as constants10, fchmodSync, fstatSync as fstatSync10, fsyncSync as fsyncSync4, lstatSync as lstatSync19, openSync as openSync10, readFileSync as readFileSync14, readlinkSync as readlinkSync6, realpathSync as realpathSync9, symlinkSync, writeSync as writeSync2 } from "fs";
+import { isAbsolute as isAbsolute15 } from "path";
 var PINNED_LAUNCHER_SCHEMA = "hasna-skills-pinned-launcher-v1";
 var LAUNCH_CWD_VARIABLE = "HASNA_SKILLS_LAUNCH_CWD";
 var PINNED_LAUNCHER_BUN_FLAGS = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install"];
@@ -16136,10 +16376,10 @@ var PINNED_LAUNCHER_ENV_PREFIXES = ["HASNA", "SKILLS", "SKILL", "MCP", "XDG", "L
 var ENV_PREFIX = new RegExp(`^(${PINNED_LAUNCHER_ENV_PREFIXES.join("|")})_`);
 var ENV_EXACT = new Set(PINNED_LAUNCHER_ENV_NAMES);
 function sha2562(bytes) {
-  return createHash18("sha256").update(bytes).digest("hex");
+  return createHash19("sha256").update(bytes).digest("hex");
 }
 function assertLauncherPath(value, code) {
-  if (typeof value !== "string" || !isAbsolute13(value) || /['\x00-\x1f\x7f]/.test(value))
+  if (typeof value !== "string" || !isAbsolute15(value) || /['\x00-\x1f\x7f]/.test(value))
     throw new Error(code);
 }
 function renderPinnedLauncher(binding) {
@@ -16229,7 +16469,7 @@ function assertPinnedLauncherRuntimeSafe(runtime) {
 }
 
 // src/lib/agent-integration.ts
-var sha3 = (data) => createHash19("sha256").update(data).digest("hex");
+var sha3 = (data) => createHash20("sha256").update(data).digest("hex");
 var ROOTS = NATIVE_SKILL_ROOTS;
 function hasTrustedDarwinAcl(fd, allowDenyOnly = false) {
   try {
@@ -16279,9 +16519,10 @@ function isSystemRootAlias(path) {
     return false;
   const target = `/private${path}`, link = `private${path}`;
   const identity5 = (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}`;
+  const directoryIdentity = (stat) => `${stat.dev}:${stat.ino}:${stat.uid}:${stat.mode}`;
   try {
     const before = lstatSync20(path, { bigint: true });
-    if (!before.isSymbolicLink() || before.uid !== 0n || readlinkSync6(path) !== link)
+    if (!before.isSymbolicLink() || before.uid !== 0n || readlinkSync7(path) !== link)
       return false;
     const directories = ["/", "/private", target].map((directory) => {
       const stat = lstatSync20(directory, { bigint: true });
@@ -16294,20 +16535,20 @@ function isSystemRootAlias(path) {
         throw new Error("Unprotected system temporary directory");
       const fd = openSync11(directory, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW);
       try {
-        if (identity5(fstatSync11(fd, { bigint: true })) !== identity5(stat) || !hasTrustedDarwinAcl(fd) || identity5(fstatSync11(fd, { bigint: true })) !== identity5(stat))
+        if (directoryIdentity(fstatSync11(fd, { bigint: true })) !== directoryIdentity(stat) || !hasTrustedDarwinAcl(fd) || directoryIdentity(fstatSync11(fd, { bigint: true })) !== directoryIdentity(stat))
           throw new Error("Unverified system alias directory ACL");
       } finally {
         closeSync11(fd);
       }
-      return { directory, identity: identity5(stat) };
+      return { directory, identity: directoryIdentity(stat) };
     });
-    return realpathSync10(path) === target && readlinkSync6(path) === link && identity5(lstatSync20(path, { bigint: true })) === identity5(before) && directories.every((item) => identity5(lstatSync20(item.directory, { bigint: true })) === item.identity);
+    return realpathSync10(path) === target && readlinkSync7(path) === link && identity5(lstatSync20(path, { bigint: true })) === identity5(before) && directories.every((item) => directoryIdentity(lstatSync20(item.directory, { bigint: true })) === item.identity);
   } catch {
     return false;
   }
 }
 function canonicalSystemPath(path) {
-  const absolute = resolve13(path), root = `/${absolute.split(sep7)[1]}`;
+  const absolute = resolve15(path), root = `/${absolute.split(sep7)[1]}`;
   if (process.platform !== "darwin" || !["/var", "/tmp", "/etc"].includes(root) || !lstatSync20(root, { throwIfNoEntry: false })?.isSymbolicLink())
     return absolute;
   if (!isSystemRootAlias(root))
@@ -16315,11 +16556,11 @@ function canonicalSystemPath(path) {
   return `/private${absolute}`;
 }
 function assertSafePath(path) {
-  let cursor = resolve13(path);
+  let cursor = resolve15(path);
   while (true) {
     if (lstatSync20(cursor, { throwIfNoEntry: false })?.isSymbolicLink() && !isSystemRootAlias(cursor))
       throw new Error(`Refusing symlink path: ${cursor}`);
-    const parent = dirname14(cursor);
+    const parent = dirname15(cursor);
     if (parent === cursor)
       return;
     cursor = parent;
@@ -16331,13 +16572,13 @@ function readRootAlias(home, agent) {
   const stat = lstatSync20(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link = readlinkSync6(alias), targetPath = resolve13(dirname14(alias), link);
+  const link = readlinkSync7(alias), targetPath = resolve15(dirname15(alias), link);
   assertSafePath(targetPath);
   const targetStat = lstatSync20(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
   const target = realpathSync10(targetPath), inside = relative6(realHome, target);
-  if (!inside || inside === ".." || inside.startsWith(`..${sep7}`) || isAbsolute14(inside))
+  if (!inside || inside === ".." || inside.startsWith(`..${sep7}`) || isAbsolute16(inside))
     throw new Error(`Agent root alias target must be inside the real home: ${alias}`);
   return { agent, home: realHome, alias, target, link, aliasIdentity: `${stat.dev}:${stat.ino}:${stat.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
 }
@@ -16363,13 +16604,13 @@ function disabledCodexSkillPaths(config, aliases) {
   const rows = skills.config;
   if (!Array.isArray(rows))
     return [];
-  if (rows.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.enabled !== "boolean" || entry.path !== undefined === (entry.name !== undefined) || entry.path !== undefined && (typeof entry.path !== "string" || !isAbsolute14(entry.path)) || entry.name !== undefined && (typeof entry.name !== "string" || !entry.name.trim())))
+  if (rows.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.enabled !== "boolean" || entry.path !== undefined === (entry.name !== undefined) || entry.path !== undefined && (typeof entry.path !== "string" || !isAbsolute16(entry.path)) || entry.name !== undefined && (typeof entry.name !== "string" || !entry.name.trim())))
     return [];
   if (rows.some((entry) => entry.name !== undefined && entry.enabled !== false))
     return [];
   const settings = new Map;
   for (const entry of rows) {
-    if (typeof entry.path !== "string" || !isAbsolute14(entry.path))
+    if (typeof entry.path !== "string" || !isAbsolute16(entry.path))
       continue;
     let document2;
     try {
@@ -16381,7 +16622,7 @@ function disabledCodexSkillPaths(config, aliases) {
       continue;
     settings.set(document2, [...settings.get(document2) ?? [], entry.enabled === false]);
   }
-  return [...settings].filter(([, values]) => values.length === 1 && values[0] === true).map(([document2]) => dirname14(document2));
+  return [...settings].filter(([, values]) => values.length === 1 && values[0] === true).map(([document2]) => dirname15(document2));
 }
 function recheckRootAliases(aliases) {
   for (const binding of aliases) {
@@ -16423,7 +16664,7 @@ function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   }
 }
 function treeHash(root) {
-  const hash2 = createHash19("sha256");
+  const hash2 = createHash20("sha256");
   let bytes = 0, files = 0;
   function visit2(path) {
     const stat = lstatSync20(path);
@@ -16455,20 +16696,20 @@ function selectNativeMigrationTargets(inventory, manifest) {
   const identities = new Set;
   const selected = [];
   for (const target of manifest.targets) {
-    if (!isAbsolute14(target.projectRoot) || resolve13(target.projectRoot) !== target.projectRoot)
+    if (!isAbsolute16(target.projectRoot) || resolve15(target.projectRoot) !== target.projectRoot)
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
-    const projectRoot = canonicalSystemPath(target.projectRoot), normalized = relative6(projectRoot, resolve13(projectRoot, target.path));
+    const projectRoot = canonicalSystemPath(target.projectRoot), normalized = relative6(projectRoot, resolve15(projectRoot, target.path));
     if (!existsSync9(projectRoot) || !lstatSync20(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     assertSafePath(projectRoot);
-    if (isAbsolute14(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
+    if (isAbsolute16(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep7}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
       throw new Error(`Invalid native migration target: ${target.path}`);
     const identity5 = `${target.agent}\x00${canonicalSystemPath(projectRoot)}\x00${normalized}`;
     if (identities.has(identity5))
       throw new Error(`Duplicate native migration target: ${target.path}`);
     identities.add(identity5);
-    const expected = canonicalSystemPath(resolve13(target.projectRoot, target.path));
-    const matches = inventory.filter((entry2) => entry2.agent === target.agent && resolve13(entry2.path) === expected);
+    const expected = canonicalSystemPath(resolve15(target.projectRoot, target.path));
+    const matches = inventory.filter((entry2) => entry2.agent === target.agent && resolve15(entry2.path) === expected);
     if (matches.length !== 1)
       throw new Error(`Native migration target was not found exactly once: ${target.agent} ${target.projectRoot}/${target.path}`);
     const entry = matches[0];
@@ -16487,7 +16728,7 @@ function projectAncestorDirectories(projects) {
       if (depth >= 100)
         throw new Error("NATIVE_SKILL_DRIFT: project ancestor discovery limit exceeded");
       directories.add(path);
-      const parent = dirname14(path);
+      const parent = dirname15(path);
       if (parent === path)
         break;
       path = parent;
@@ -16496,7 +16737,7 @@ function projectAncestorDirectories(projects) {
   return [...directories];
 }
 function isCodexSkillDiscoveryInput(path) {
-  for (let cursor = canonicalSystemPath(path);cursor !== dirname14(cursor); cursor = dirname14(cursor)) {
+  for (let cursor = canonicalSystemPath(path);cursor !== dirname15(cursor); cursor = dirname15(cursor)) {
     if (ROOTS.some(([agent, root]) => agent === "codex" && cursor.endsWith(join23(sep7, root))))
       return true;
   }
@@ -16504,9 +16745,9 @@ function isCodexSkillDiscoveryInput(path) {
 }
 function inventoryNativeSkills(home = homedir2(), options = {}) {
   home = canonicalSystemPath(home);
-  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute14(options.reviewedCacheAlias) || resolve13(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
+  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute16(options.reviewedCacheAlias) || resolve15(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
     throw new Error("A reviewed cache alias requires vendor inventory and an exact absolute path");
-  if (options.disabledVendorPaths?.some((path) => !isAbsolute14(path) || resolve13(path) !== path))
+  if (options.disabledVendorPaths?.some((path) => !isAbsolute16(path) || resolve15(path) !== path))
     throw new Error("Disabled vendor paths must be exact absolute paths");
   const reviewedCacheAlias = options.reviewedCacheAlias === undefined ? undefined : canonicalSystemPath(options.reviewedCacheAlias);
   const disabledVendorPaths = new Set((options.disabledVendorPaths ?? []).map(canonicalSystemPath));
@@ -16525,7 +16766,7 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
           roots.push(["sumi", canonicalAgentPath(join23(project, directory, name), aliases)]);
   }
   const installationInputs = options.codexInstallationInputRoots ?? [];
-  if (installationInputs.some((input) => resolve13(input) !== input || realpathSync10(input) !== input || roots.some(([agent, path]) => agent === "codex" && (path === input || path.startsWith(input + sep7) || input.startsWith(path + sep7)))))
+  if (installationInputs.some((input) => resolve15(input) !== input || realpathSync10(input) !== input || roots.some(([agent, path]) => agent === "codex" && (path === input || path.startsWith(input + sep7) || input.startsWith(path + sep7)))))
     throw new Error("Native installation input overlaps an unconditional skill-loading root");
   const entries = [], seen = new Set;
   const cacheScans = new Map, maxAliasProofEntries = 1e4;
@@ -16539,11 +16780,11 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
   }
   let reviewedCacheAliasFound = false;
   function verifiedSiblingCacheAlias(agent, path, parent) {
-    const link = readlinkSync6(path), lexicalTarget = resolve13(parent, link);
-    if (isAbsolute14(link) ? link !== lexicalTarget : dirname14(link) !== ".")
+    const link = readlinkSync7(path), lexicalTarget = resolve15(parent, link);
+    if (isAbsolute16(link) ? link !== lexicalTarget : dirname15(link) !== ".")
       return false;
     const target = canonicalSystemPath(lexicalTarget);
-    if (dirname14(target) !== parent)
+    if (dirname15(target) !== parent)
       return false;
     if (!lstatSync20(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
@@ -16592,17 +16833,17 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
       }
       const bridge = (!vendor || agent === "sumi") && isOwnedCliBridge(path, bridgePaths);
       const rootAlias = aliases.find((item) => path === item.target || path.startsWith(item.target + sep7));
-      entries.push({ agent, path, hash: treeHash(path), managed, vendor, ...agent === "codex" || isCodexSkillDiscoveryInput(path) ? { codexHome: process.env.CODEX_HOME ?? join23(home, ".codex") } : {}, ...agent === "codex" && path.startsWith(canonicalAgentPath(join23(home, ".codex", "skills", ".system"), aliases) + sep7) ? { system: true } : {}, ...bridge ? { bridge: true, bridgeHome: resolve13(home) } : {}, ...rootAlias ? { rootAlias } : {} });
+      entries.push({ agent, path, hash: treeHash(path), managed, vendor, ...agent === "codex" || isCodexSkillDiscoveryInput(path) ? { codexHome: process.env.CODEX_HOME ?? join23(home, ".codex") } : {}, ...agent === "codex" && path.startsWith(canonicalAgentPath(join23(home, ".codex", "skills", ".system"), aliases) + sep7) ? { system: true } : {}, ...bridge ? { bridge: true, bridgeHome: resolve15(home) } : {}, ...rootAlias ? { rootAlias } : {} });
       return scan;
     }
     if (depth > (agent === "sumi" ? 32 : vendor ? 32 : 3))
       return { ...scan, complete: false };
     const children = [], directory = opendirSync3(path);
     try {
-      let child;
-      while ((child = directory.readSync()) !== null) {
-        admit(join23(path, child.name));
-        children.push(child);
+      let child2;
+      while ((child2 = directory.readSync()) !== null) {
+        admit(join23(path, child2.name));
+        children.push(child2);
       }
     } finally {
       directory.closeSync();
@@ -16618,15 +16859,15 @@ function inventoryNativeSkills(home = homedir2(), options = {}) {
       const isVendor = vendor || name === ".system";
       if (isVendor && !options.includeVendor)
         continue;
-      const child = join23(path, name);
-      if (isVendor && lstatSync20(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
-        const target = statSync9(child, { throwIfNoEntry: false });
-        if (target?.isFile() || pluginCache && target?.isDirectory() && verifiedSiblingCacheAlias(agent, child, path)) {
+      const child2 = join23(path, name);
+      if (isVendor && lstatSync20(child2, { throwIfNoEntry: false })?.isSymbolicLink()) {
+        const target = statSync9(child2, { throwIfNoEntry: false });
+        if (target?.isFile() || pluginCache && target?.isDirectory() && verifiedSiblingCacheAlias(agent, child2, path)) {
           scan.entries++;
           continue;
         }
       }
-      const childScan = visit2(agent, child, isVendor, depth + 1, pluginCache, true, configuredRoot);
+      const childScan = visit2(agent, child2, isVendor, depth + 1, pluginCache, true, configuredRoot);
       scan.complete &&= childScan.complete;
       scan.hasSkills ||= childScan.hasSkills;
       scan.entries += childScan.entries;
@@ -16762,7 +17003,7 @@ function configureHooks(config, agent, command, profileId, nativeReady) {
 function disableCodexSkills(text2, skills, aliases, bridgePath) {
   const bundled = disableCodexBundledSkills(text2);
   let result = normalizeCodexInlinePathConfig(bundled);
-  const bridgeSelector = (entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME || typeof entry.path === "string" && [resolve13(bridgePath), resolve13(join23(bridgePath, "SKILL.md"))].includes(canonicalAgentPath(entry.path, aliases));
+  const bridgeSelector = (entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME || typeof entry.path === "string" && [resolve15(bridgePath), resolve15(join23(bridgePath, "SKILL.md"))].includes(canonicalAgentPath(entry.path, aliases));
   const previousConfig = Bun.TOML.parse(bundled).skills?.config;
   if (previousConfig !== undefined && (!Array.isArray(previousConfig) || previousConfig.some((entry) => !entry || typeof entry !== "object" || entry.path !== undefined && entry.name !== undefined)))
     throw new Error("Codex skill controls require one path or name selector per [[skills.config]] entry; review ambiguous entries before running skills hook install");
@@ -16774,7 +17015,7 @@ function disableCodexSkills(text2, skills, aliases, bridgePath) {
     result = result.replace(CODEX_SKILL_CONFIG_SECTIONS, (section) => {
       const parsed = Bun.TOML.parse(section);
       const declared = parsed.skills?.config?.[0];
-      if (!declared || !(skill.enabled && bridgeSelector(declared)) && !(typeof declared.path === "string" && [resolve13(path), resolve13(skill.path)].includes(canonicalAgentPath(declared.path, aliases))))
+      if (!declared || !(skill.enabled && bridgeSelector(declared)) && !(typeof declared.path === "string" && [resolve15(path), resolve15(skill.path)].includes(canonicalAgentPath(declared.path, aliases))))
         return section;
       found = true;
       return /^\s*enabled\s*=/m.test(section) ? section.replace(/^\s*enabled\s*=.*$/m, `enabled = ${skill.enabled}`) : `${section.trimEnd()}
@@ -16795,7 +17036,7 @@ enabled = false
   return result;
 }
 function assertCodexInstallationInputs(home, projectDirs, inputs) {
-  const nativeRoots = [home, ...projectAncestorDirectories(projectDirs)].flatMap((directory) => ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => resolve13(directory, path)));
+  const nativeRoots = [home, ...projectAncestorDirectories(projectDirs)].flatMap((directory) => ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => resolve15(directory, path)));
   if (inputs.some((input) => nativeRoots.some((root) => root === input || root.startsWith(input + sep7) || input.startsWith(root + sep7))))
     throw new Error("Native installation input overlaps an unconditional skill-loading root");
 }
@@ -16811,9 +17052,9 @@ function planAgentIntegration(options) {
     throw new Error("Invalid existing Skills bridge policy");
   if (policy.bridge?.agents !== undefined && (!Array.isArray(policy.bridge.agents) || policy.bridge.agents.some((agent) => !INTEGRATION_AGENTS.includes(agent))))
     throw new Error("Invalid existing bridge agent inventory");
-  for (const field of ["commands", "profiles"])
-    if (policy.bridge?.[field] !== undefined && (!policy.bridge[field] || typeof policy.bridge[field] !== "object" || Array.isArray(policy.bridge[field]) || Object.entries(policy.bridge[field]).some(([key, value]) => !INTEGRATION_AGENTS.includes(key) || typeof value !== "string" || !value || value.includes("\x00"))))
-      throw new Error(`Invalid existing bridge ${field} binding`);
+  for (const field2 of ["commands", "profiles"])
+    if (policy.bridge?.[field2] !== undefined && (!policy.bridge[field2] || typeof policy.bridge[field2] !== "object" || Array.isArray(policy.bridge[field2]) || Object.entries(policy.bridge[field2]).some(([key, value]) => !INTEGRATION_AGENTS.includes(key) || typeof value !== "string" || !value || value.includes("\x00"))))
+      throw new Error(`Invalid existing bridge ${field2} binding`);
   const priorAgents = policy.bridge?.agents ?? [];
   const profileId = options.profileId ?? policy.profileId ?? "default";
   const validateProfile = (value) => {
@@ -16828,13 +17069,18 @@ function planAgentIntegration(options) {
     return [agent, { command, profileId: profileId2 }];
   }));
   const retainedAgents = [];
+  const priorExecutables = policy.bridge?.discoveryExecutables ?? {};
+  const executables = new Map;
   const discoveries = [...new Set(options.agents)].map((agent) => {
+    const prior = priorExecutables[agent];
+    const executable2 = discoveryExecutable(agent) ?? (prior ? recordedDiscoveryExecutable(agent, prior) : null);
+    executables.set(agent, executable2);
     const retainedReview = options.discoveryInputs === undefined && policy.bridge?.discovery?.[agent]?.method === "reviewed" ? { ...policy.bridge.discovery[agent], ...agent === "codex" ? { codexDisabledPluginSkills: policy.bridge.codexPluginSkills ?? [] } : {} } : undefined;
     if (retainedReview) {
       assertManagedAgentBridge(agent, { home, dataDir: dataDir2, projectDir: options.projectDir ?? home });
       retainedAgents.push(agent);
     }
-    return resolveAgentDiscovery({ home, agent, reviewed: options.discoveryInputs, retainedReview, canonical: (path) => canonicalAgentPath(path, aliases) });
+    return resolveAgentDiscovery({ home, agent, reviewed: options.discoveryInputs, retainedReview, canonical: (path) => canonicalAgentPath(path, aliases), executable: executable2 });
   });
   const codexConfigBefore = options.agents.includes("codex") ? readOptional(canonicalAgentPath(join23(home, ".codex", "config.toml"), aliases)) : null;
   const codexConfig = Bun.TOML.parse(codexConfigBefore ?? "");
@@ -16842,7 +17088,7 @@ function planAgentIntegration(options) {
   const codexPathConfig = options.agents.includes("codex") ? disableCodexSkills(codexConfigBefore ?? "", nativeSkills, aliases, canonicalAgentPath(join23(home, ".codex/skills", CLI_BRIDGE_NAME), aliases)) : undefined;
   const plannedCodexRules = codexPathConfig === undefined ? undefined : Bun.TOML.parse(codexPathConfig).skills?.config ?? [];
   const observedNativeSources = [];
-  const codexPluginControls = options.codexNativeCatalog ? reviewCodexPluginControls(options.codexNativeCatalog, nativeSkills.filter((entry) => entry.agent === "codex" && entry.vendor).map((entry) => join23(entry.path, "SKILL.md")), canonicalAgentPath(join23(home, ".codex/plugins/cache"), aliases), resolve13(options.projectDir ?? home), (path) => {
+  const codexPluginControls = options.codexNativeCatalog ? reviewCodexPluginControls(options.codexNativeCatalog, nativeSkills.filter((entry) => entry.agent === "codex" && entry.vendor).map((entry) => join23(entry.path, "SKILL.md")), canonicalAgentPath(join23(home, ".codex/plugins/cache"), aliases), resolve15(options.projectDir ?? home), (path) => {
     const bytes = readNativeBytes(path, 1024 * 1024);
     observedNativeSources.push({ path, sha256: sha3(bytes) });
     return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
@@ -16963,7 +17209,7 @@ function planAgentIntegration(options) {
     const { codexInstallationInputs: previousInputs, ...current } = rebound;
     const inputs = codexPluginSourceInputs.map((input) => input.sourceRoot);
     const directories = options.codexNativeCatalog || !previousInputs ? captureDiscoveryDirectories((binding.directories ?? []).filter((directory) => inputs.some((root) => root.startsWith(directory.path + sep7))).map((directory) => directory.path), inputs) : previousInputs.directories;
-    const installed = codexPluginSourceInputs.length ? { ...current, codexInstallationInputs: { version: "codex-cli 0.160.0", catalogSha256: codexPluginSkillReview.catalogSha256, plugins: codexPluginSourceInputs, ...directories?.length ? { directories } : {} } } : current;
+    const installed = codexPluginSourceInputs.length ? { ...current, codexInstallationInputs: { version: codexPluginSkillReview.version, catalogSha256: codexPluginSkillReview.catalogSha256, plugins: codexPluginSourceInputs, ...directories?.length ? { directories } : {} } } : current;
     return captureRetiredCodexDiscovery(installed, codexPluginSkills, Bun.TOML.parse(changes.find((change) => change.path === canonicalAgentPath(join23(home, ".codex/config.toml"), aliases))?.after ?? codexConfigBefore ?? "").skills?.config ?? []);
   });
   const nextPolicy = { ...policy, version: 1, loading: "cli", profileId, bridge: {
@@ -16971,7 +17217,7 @@ function planAgentIntegration(options) {
     version: CLI_BRIDGE_VERSION,
     digest: CLI_BRIDGE_DIGEST,
     agents: [...new Set([...priorAgents, ...options.agents])].sort(),
-    home: resolve13(home),
+    home: resolve15(home),
     includeVendor: true,
     ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join23(dataDir2, "agent-hooks", "hermes.js"), runtime: process.execPath, sha256: sha3(renderHermesSupervisor(bindings.get("hermes").command, bindings.get("hermes").profileId)) } } } : {},
     commands: { ...policy.bridge?.commands, ...Object.fromEntries([...bindings].map(([agent, binding]) => [agent, binding.command])) },
@@ -16981,19 +17227,30 @@ function planAgentIntegration(options) {
     ...options.codexNativeCatalog || codexPluginSkills.length || codexInactivePlugins.length || codexPluginSourceInputs.length ? { codexPluginSkills, codexInactivePlugins, codexPluginSkillReview } : {},
     discovery: { ...policy.bridge?.discovery, ...Object.fromEntries(discoveryAfter.map((binding) => [binding.agent, binding])) }
   } };
+  const discoveryExecutables = { ...priorExecutables };
+  for (const [agent, executable2] of executables) {
+    if (executable2)
+      discoveryExecutables[agent] = executable2;
+    else
+      delete discoveryExecutables[agent];
+  }
+  if (Object.keys(discoveryExecutables).length)
+    nextPolicy.bridge.discoveryExecutables = discoveryExecutables;
+  else
+    delete nextPolicy.bridge.discoveryExecutables;
   const serializedPolicy = serializeManagedSkillPolicy(nextPolicy);
   if (JSON.stringify(policy) !== JSON.stringify(nextPolicy))
     changes.push({ path: policyPath, before: previousPolicy, after: serializedPolicy });
   recheckRootAliases(aliases);
   return { dataDir: dataDir2, profileId, changes, nativeSkills, ...observedSettings ? { observedSettings } : {}, ...observedNativeSources.length ? { observedNativeSources } : {}, ...nextPolicy.bridge.codexPluginSkillReview ? { codexPluginSkillReview: nextPolicy.bridge.codexPluginSkillReview } : {}, observedPolicy: { path: policyPath, before: previousPolicy }, discoveryBefore: discoveries, discoveryAfter, ...aliases.length ? { rootAliases: aliases } : {}, ...retainedAgents.length ? { retainedReviewChecks: { home, projectDir: options.projectDir ?? home, agents: retainedAgents } } : {} };
 }
-function hookProjectionRefusal(reason) {
-  throw new Error(`CLAUDE_MANAGED_HOOK_${reason}`);
+function hookProjectionRefusal(reason2) {
+  throw new Error(`CLAUDE_MANAGED_HOOK_${reason2}`);
 }
 function projectedHookAcl(path, observed) {
   if (process.platform !== "darwin")
     return;
-  const identity5 = (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}:${stat.nlink}:${stat.size}:${stat.mtimeNs}`;
+  const identity5 = observed.isDirectory() ? (stat) => `${stat.dev}:${stat.ino}:${stat.uid}:${stat.mode}` : (stat) => `${stat.dev}:${stat.ino}:${stat.ctimeNs}:${stat.uid}:${stat.mode}:${stat.nlink}:${stat.size}:${stat.mtimeNs}`;
   const fd = openSync11(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK | (observed.isDirectory() ? constants11.O_DIRECTORY : 0));
   try {
     if (identity5(fstatSync11(fd, { bigint: true })) !== identity5(observed) || !hasTrustedDarwinAcl(fd, true) || identity5(fstatSync11(fd, { bigint: true })) !== identity5(observed) || identity5(lstatSync20(path, { bigint: true })) !== identity5(observed))
@@ -17004,18 +17261,18 @@ function projectedHookAcl(path, observed) {
 }
 function projectedHookExecutable(command, expectedResolved) {
   try {
-    if (!isAbsolute14(command) || /[\0\r\n]/.test(command) || resolve13(command) !== command)
+    if (!isAbsolute16(command) || /[\0\r\n]/.test(command) || resolve15(command) !== command)
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     command = canonicalSystemPath(command);
     const parents2 = (file = command) => {
       const result = [];
-      for (let path = dirname14(file);; path = dirname14(path)) {
+      for (let path = dirname15(file);; path = dirname15(path)) {
         const stat = lstatSync20(path, { bigint: true });
-        if (!stat.isDirectory() || (stat.mode & 0o022n) !== 0n && !(stat.uid === 0n && (stat.mode & 0o1000n) !== 0n))
+        if (!stat.isDirectory() || !trustedAncestorOwner(stat.uid) || (stat.mode & 0o022n) !== 0n && !(stat.uid === 0n && (stat.mode & 0o1000n) !== 0n))
           hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
         projectedHookAcl(path, stat);
         result.push(`${path}:${stat.dev}:${stat.ino}:${stat.uid}:${stat.mode}`);
-        if (dirname14(path) === path)
+        if (dirname15(path) === path)
           break;
       }
       return result;
@@ -17025,22 +17282,33 @@ function projectedHookExecutable(command, expectedResolved) {
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     const linkIdentity = (stat) => `${stat.dev}:${stat.ino}:${stat.mode}:${stat.uid}:${stat.ctimeNs}`;
     const target = resolveLauncherCommand(command), resolved = target.entry;
+    const direct = () => link.isSymbolicLink() ? directAliasTarget(command) === target.physical : target.physical === command;
+    if (!direct())
+      hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     if (expectedResolved !== undefined && resolved !== expectedResolved)
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     let launcher, launcherParentIdentity;
+    let runtime;
     if (target.pinned) {
       launcherParentIdentity = parents2(target.physical);
       launcher = snapshot(target.physical, false);
       projectedHookAcl(launcher.file, launcher.stat);
       if (launcher.sha256 !== target.pinned.sha256 || (launcher.stat.mode & 0o100n) === 0n)
         hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
-      assertPinnedLauncherRuntimeSafe(target.pinned.runtime);
+      const path = target.pinned.runtime;
+      assertPinnedLauncherRuntimeSafe(path);
+      if (resolve15(path) !== path)
+        hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+      runtime = { path, parents: parents2(path), stat: lstatSync20(path, { bigint: true }) };
+      if (!runtime.stat.isFile())
+        hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+      projectedHookAcl(path, runtime.stat);
     }
     const resolvedParentIdentity = parents2(resolved);
-    const manifest = snapshot(join23(dirname14(dirname14(resolved)), "package.json"), false, { readOnlyPackage: true });
+    const manifest = snapshot(join23(dirname15(dirname15(resolved)), "package.json"), false, { readOnlyPackage: true });
     projectedHookAcl(manifest.file, manifest.stat);
     const pkg = JSON.parse(manifest.text);
-    if (pkg.name !== "@hasna/skills" || !/^\d+\.\d+\.\d+$/.test(pkg.version) || pkg.bin?.skills !== "bin/index.js" || resolved !== join23(dirname14(manifest.file), "bin/index.js"))
+    if (pkg.name !== "@hasna/skills" || !/^\d+\.\d+\.\d+$/.test(pkg.version) || pkg.bin?.skills !== "bin/index.js" || resolved !== join23(dirname15(manifest.file), "bin/index.js"))
       hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
     const cli = snapshot(resolved, false, { readOnlyPackage: true });
     projectedHookAcl(cli.file, cli.stat);
@@ -17049,7 +17317,7 @@ function projectedHookExecutable(command, expectedResolved) {
     const recheck = () => {
       try {
         const again = resolveLauncherCommand(command);
-        if (again.entry !== resolved || again.physical !== target.physical || linkIdentity(lstatSync20(command, { bigint: true })) !== linkIdentity(link) || !isDeepStrictEqual6(parents2(), parentIdentity) || !isDeepStrictEqual6(parents2(resolved), resolvedParentIdentity))
+        if (again.entry !== resolved || again.physical !== target.physical || linkIdentity(lstatSync20(command, { bigint: true })) !== linkIdentity(link) || !direct() || !isDeepStrictEqual6(parents2(), parentIdentity) || !isDeepStrictEqual6(parents2(resolved), resolvedParentIdentity))
           hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
         if (launcher) {
           if (!isDeepStrictEqual6(parents2(target.physical), launcherParentIdentity))
@@ -17057,6 +17325,12 @@ function projectedHookExecutable(command, expectedResolved) {
           projectedHookAcl(launcher.file, launcher.stat);
           unchanged2(launcher);
         }
+        if (runtime) {
+          assertPinnedLauncherRuntimeSafe(runtime.path);
+          if (!isDeepStrictEqual6(parents2(runtime.path), runtime.parents))
+            hookProjectionRefusal("EXECUTABLE_UNVERIFIED");
+          projectedHookAcl(runtime.path, runtime.stat);
+        }
         projectedHookAcl(cli.file, cli.stat);
         projectedHookAcl(manifest.file, manifest.stat);
         unchanged2(cli);
@@ -17083,7 +17357,7 @@ function planClaudeManagedHookProjection(options) {
   } catch {
     hookProjectionRefusal("TARGET_INVALID");
   }
-  const home = resolve13(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
+  const home = resolve15(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
   const policyPath = join23(dataDir2, "agent-policy.json");
   let policyBytes, settingsBytes, settingsPath, command, profile;
   try {
@@ -17175,29 +17449,28 @@ function planClaudePreToolUseHookUpdate(options) {
   return planClaudeHookEventsUpdate({ ...options, events: ["PreToolUse"] });
 }
 function claudeSettingsConsumers(home, path, discoveries, aliases) {
-  const canonical6 = (value) => canonicalAgentPath(value, aliases);
+  const canonical7 = (value) => canonicalAgentPath(value, aliases);
   const containsSettings = (root) => {
-    const distance = relative6(canonical6(root), path);
-    return distance === "" || distance !== ".." && !distance.startsWith(`..${sep7}`) && !isAbsolute14(distance);
+    const distance = relative6(canonical7(root), path);
+    return distance === "" || distance !== ".." && !distance.startsWith(`..${sep7}`) && !isAbsolute16(distance);
   };
-  return discoveries.filter((binding) => binding.agent === "claude" || binding.agent === "opencode" || canonical6(join23(home, AGENT_ADAPTERS[binding.agent].config)) === path || binding.sources.some((source) => canonical6(source.path) === path) || binding.roots.some(containsSettings) || binding.directories?.some((directory) => containsSettings(directory.path))).map((binding) => binding.agent);
+  return discoveries.filter((binding) => binding.agent === "claude" || binding.agent === "opencode" || canonical7(join23(home, AGENT_ADAPTERS[binding.agent].config)) === path || binding.sources.some((source) => canonical7(source.path) === path) || binding.roots.some(containsSettings) || binding.directories?.some((directory) => containsSettings(directory.path))).map((binding) => binding.agent);
 }
-function verifyCoordinatedDiscovery(binding, home, aliases) {
+function verifyCoordinatedDiscovery(binding, home, aliases, executable2) {
   try {
     if (binding.method !== "automatic" && binding.method !== "reviewed")
       throw new Error("Invalid managed discovery method");
     verifyAgentDiscovery(binding);
-    if (binding.method === "automatic") {
-      const current = resolveAgentDiscovery({ home, agent: binding.agent, canonical: (path) => canonicalAgentPath(path, aliases) });
-      if (JSON.stringify(current) !== JSON.stringify(binding))
-        throw new Error("Configured native discovery roots changed during Claude update");
-    }
+    if (binding.method === "automatic")
+      verifyAutomaticDiscoveryClosure(binding, { home, canonical: (path) => canonicalAgentPath(path, aliases), change: "Configured native discovery roots changed during Claude update", executable: executable2 });
   } catch (error) {
+    if (isDiscoveryRootUnresolved(error))
+      throw error;
     throw new Error(`NATIVE_SKILL_DRIFT: ${error.message}`);
   }
 }
 function planClaudeHookEventsUpdate(options) {
-  const home = resolve13(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
+  const home = resolve15(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
   const policyPath = join23(dataDir2, "agent-policy.json");
   assertSafePath(policyPath);
   const snapshot2 = readManagedSkillPolicySnapshot(dataDir2);
@@ -17223,8 +17496,9 @@ function planClaudeHookEventsUpdate(options) {
   });
   if (discoveries.length !== agents.length || !agents.includes("claude"))
     throw new Error("Missing managed Claude discovery coverage");
+  const discoveryExecutables = bridge.discoveryExecutables;
   for (const binding of discoveries)
-    verifyCoordinatedDiscovery(binding, home, aliases);
+    verifyCoordinatedDiscovery(binding, home, aliases, discoveryExecutables?.[binding.agent]);
   const consumers = claudeSettingsConsumers(home, path, discoveries, aliases);
   for (const agent of consumers)
     assertManagedAgentBridge(agent, { home, dataDir: dataDir2, projectDir: home });
@@ -17259,13 +17533,14 @@ function planClaudeHookEventsUpdate(options) {
     observedPolicy: { path: policyPath, before: snapshot2.text },
     discoveryBefore: discoveries,
     discoveryAfter,
+    ...discoveryExecutables ? { discoveryExecutables } : {},
     rootAliases: aliases,
     managedAgentChecks: { home, agents: consumers }
   };
 }
 function atomicWrite2(path, content) {
   assertSafePath(path);
-  mkdirSync6(dirname14(path), { recursive: true, mode: 448 });
+  mkdirSync6(dirname15(path), { recursive: true, mode: 448 });
   const temporary = `${path}.skills-${randomUUID3()}`;
   try {
     writeFileSync6(temporary, content, { mode: 384, flag: "wx" });
@@ -17280,7 +17555,7 @@ function planAgentSettingsWitnessUpgrade(options) {
     throw new Error("Invalid Codex witness target version");
   if (options.targetClaudeVersion !== undefined && (options.agent !== "claude" || ![3, 4].includes(options.targetClaudeVersion)))
     throw new Error("Invalid Claude witness target version");
-  const home = resolve13(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
+  const home = resolve15(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
   const snapshot2 = readManagedSkillPolicySnapshot(dataDir2);
   if (!snapshot2 || sha3(snapshot2.text) !== options.expectedPolicySha256)
     throw new Error("Managed policy preimage changed");
@@ -17340,7 +17615,7 @@ function planAgentSettingsWitnessUpgrade(options) {
   const replacement = { ...binding, sources: rebound };
   verifyAgentDiscovery(replacement);
   const after = serializeManagedSkillPolicy({ ...policy, bridge: { ...policy.bridge, discovery: { ...policy.bridge.discovery, [options.agent]: replacement } } });
-  return { dataDir: dataDir2, profileId: policy.profileId, changes: [{ path: join23(dataDir2, "agent-policy.json"), before: snapshot2.text, after }], nativeSkills: [], observedPolicy: { path: join23(dataDir2, "agent-policy.json"), before: snapshot2.text }, observedSettings: { path: configPath, before: settings }, discoveryBefore: [replacement], discoveryAfter: [replacement], rootAliases: aliases, managedAgentChecks: { home, agents: [options.agent] }, settingsWitnessUpgrade: { agent: options.agent, path: configPath, fromHashMode: previous.hashMode ?? "bytes", fromSha256: previous.sha256, toHashMode: next.hashMode, toSha256: next.sha256, reviewedPreimage: options.reviewedPreimage, currentSettingsSha256: options.expectedSettingsSha256, replacedWitnesses: replaced.map((source) => ({ hashMode: source.hashMode ?? "bytes", sha256: source.sha256 })) } };
+  return { dataDir: dataDir2, profileId: policy.profileId, changes: [{ path: join23(dataDir2, "agent-policy.json"), before: snapshot2.text, after }], nativeSkills: [], observedPolicy: { path: join23(dataDir2, "agent-policy.json"), before: snapshot2.text }, observedSettings: { path: configPath, before: settings }, discoveryBefore: [replacement], discoveryAfter: [replacement], ...policy.bridge.discoveryExecutables ? { discoveryExecutables: policy.bridge.discoveryExecutables } : {}, rootAliases: aliases, managedAgentChecks: { home, agents: [options.agent] }, settingsWitnessUpgrade: { agent: options.agent, path: configPath, fromHashMode: previous.hashMode ?? "bytes", fromSha256: previous.sha256, toHashMode: next.hashMode, toSha256: next.sha256, reviewedPreimage: options.reviewedPreimage, currentSettingsSha256: options.expectedSettingsSha256, replacedWitnesses: replaced.map((source) => ({ hashMode: source.hashMode ?? "bytes", sha256: source.sha256 })) } };
 }
 function applyAgentIntegration(plan, options = {}) {
   const roots = plan.changes.flatMap((change) => {
@@ -17358,10 +17633,10 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     throw new Error("Native settings changed after witness planning");
   const policyPath = join23(plan.dataDir, "agent-policy.json");
   assertSafePath(policyPath);
-  const currentText = (path) => resolve13(path) === resolve13(policyPath) ? readManagedSkillPolicySnapshot(plan.dataDir)?.text ?? null : readOptional(path);
+  const currentText = (path) => resolve15(path) === resolve15(policyPath) ? readManagedSkillPolicySnapshot(plan.dataDir)?.text ?? null : readOptional(path);
   readManagedSkillPolicySnapshot(plan.dataDir);
   for (const change of plan.changes)
-    if (resolve13(change.path) === resolve13(policyPath))
+    if (resolve15(change.path) === resolve15(policyPath))
       parseManagedSkillPolicy(change.after);
   const aliases = plan.rootAliases ?? [];
   assertCurrent();
@@ -17382,7 +17657,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     assertManagedAgentBridgeWithDiscovery(agent, { home: plan.managedAgentChecks.home, dataDir: plan.dataDir, projectDir: plan.managedAgentChecks.home }, provenDiscovery?.agent === agent ? provenDiscovery : undefined);
   for (const binding of plan.discoveryBefore ?? []) {
     if (plan.managedAgentChecks)
-      verifyCoordinatedDiscovery(binding, plan.managedAgentChecks.home, aliases);
+      verifyCoordinatedDiscovery(binding, plan.managedAgentChecks.home, aliases, plan.discoveryExecutables?.[binding.agent]);
     else
       verifyAgentDiscovery(binding);
   }
@@ -17414,7 +17689,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
       recheckRootAliases(aliases);
       if (currentText(change.path) !== change.before)
         throw new Error(`Configuration changed after planning: ${change.path}`);
-      for (let directory = dirname14(change.path);!existsSync9(directory); directory = dirname14(directory))
+      for (let directory = dirname15(change.path);!existsSync9(directory); directory = dirname15(directory))
         createdDirectories.add(directory);
       const after = change.after;
       atomicWrite2(change.path, after);
@@ -17429,7 +17704,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
       throw new Error("Native settings changed during witness application");
     for (const binding of plan.discoveryAfter ?? []) {
       if (plan.managedAgentChecks)
-        verifyCoordinatedDiscovery(binding, plan.managedAgentChecks.home, aliases);
+        verifyCoordinatedDiscovery(binding, plan.managedAgentChecks.home, aliases, plan.discoveryExecutables?.[binding.agent]);
       else
         verifyAgentDiscovery(binding);
     }
@@ -17486,7 +17761,7 @@ function writeArchiveJournal(path, value) {
     closeSync11(descriptor);
     descriptor = undefined;
     renameSync3(temporary, path);
-    syncArchiveDirectory(dirname14(path));
+    syncArchiveDirectory(dirname15(path));
   } finally {
     if (descriptor !== undefined)
       closeSync11(descriptor);
@@ -17544,14 +17819,14 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
   };
   assertSafePath(archiveRoot);
   const created = [];
-  for (let path = archiveRoot;!existsSync9(path); path = dirname14(path))
+  for (let path = archiveRoot;!existsSync9(path); path = dirname15(path))
     created.push(path);
   mkdirSync6(archiveRoot, { recursive: true, mode: 448 });
   try {
     for (const directory of created)
       syncArchiveDirectory(directory);
     if (created.length)
-      syncArchiveDirectory(dirname14(created.at(-1)));
+      syncArchiveDirectory(dirname15(created.at(-1)));
     writeArchiveJournal(receiptPath, journal);
     for (const [index, entry] of selected.entries()) {
       assertCurrent();
@@ -17564,7 +17839,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
       writeArchiveJournal(receiptPath, journal);
       renameSync3(move.source, move.archive);
       moved.push(move);
-      syncArchiveDirectory(dirname14(move.source));
+      syncArchiveDirectory(dirname15(move.source));
       syncArchiveDirectory(archiveRoot);
       verifyArchive(move);
       move.status = "archived";
@@ -17601,7 +17876,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
         }
         if (entry.discoveryOnly) {
           linkSync2(entry.archive, entry.source);
-          syncArchiveDirectory(dirname14(entry.source));
+          syncArchiveDirectory(dirname15(entry.source));
           unlinkSync4(entry.archive);
         } else {
           if (lstatSync20(entry.source, { throwIfNoEntry: false })) {
@@ -17612,7 +17887,7 @@ function archiveNativeSkillsUnlocked(inventory, options, assertCurrent) {
           renameSync3(entry.archive, entry.source);
         }
         entry.status = "restored";
-        syncArchiveDirectory(dirname14(entry.source));
+        syncArchiveDirectory(dirname15(entry.source));
         syncArchiveDirectory(archiveRoot);
       } catch {
         entry.status = "recovery-required";
@@ -17637,7 +17912,7 @@ function isInertCodexPluginCacheCopy(entry, cache, allowedHostPaths, read2) {
       return false;
     const document2 = join23(entry.path, "SKILL.md");
     const inside = relative6(cache, entry.path);
-    if (!inside || isAbsolute14(inside) || inside.split(sep7).some((segment) => segment === ".."))
+    if (!inside || isAbsolute16(inside) || inside.split(sep7).some((segment) => segment === ".."))
       return false;
     assertSafePath(entry.path);
     if (!lstatSync20(cache).isDirectory() || !lstatSync20(entry.path).isDirectory() || !lstatSync20(document2).isFile())
@@ -17657,7 +17932,7 @@ function assertManagedAgentBridge(agent, options = {}) {
   assertManagedAgentBridgeWithDiscovery(agent, options);
 }
 function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscovery) {
-  const home = resolve13(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
+  const home = resolve15(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
   assertSafePath(join23(dataDir2, "agent-policy.json"));
   const snapshot2 = readManagedSkillPolicySnapshot(dataDir2);
   if (!snapshot2)
@@ -17755,12 +18030,11 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
     verifyAgentDiscovery(agent === "codex" ? { ...discovery, codexDisabledPluginSkills: binding.codexPluginSkills ?? [] } : discovery, options.codexDiscoveryRecovery);
     if (agent === "sumi" && discovery.method === "reviewed")
       resolveAgentDiscovery({ home, agent, retainedReview: discovery, canonical: (path) => canonicalAgentPath(path, aliases) });
-    if (discovery.method === "automatic") {
-      const current = resolveAgentDiscovery({ home, agent, canonical: (path) => canonicalAgentPath(path, aliases) });
-      if (JSON.stringify(current) !== JSON.stringify(discovery))
-        throw new Error("Configured native discovery roots changed");
-    }
+    if (discovery.method === "automatic")
+      verifyAutomaticDiscoveryClosure(discovery, { home, canonical: (path) => canonicalAgentPath(path, aliases), change: "Configured native discovery roots changed", executable: binding.discoveryExecutables?.[agent] });
   } catch (error) {
+    if (isDiscoveryRootUnresolved(error))
+      throw error;
     throw new Error(`NATIVE_SKILL_DRIFT: ${error.message}`);
   }
   let installationInputRoots = [];
@@ -18053,9 +18327,9 @@ function writeManagedSkillDirUnlocked(dir, skillMd, options, assertCurrent) {
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
-  const parentDir = dirname15(dir);
+  const parentDir = dirname16(dir);
   mkdirSync7(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync(join25(parentDir, `.hasna-skills-write-${basename7(dir)}-`));
+  const transactionDir = mkdtempSync(join25(parentDir, `.hasna-skills-write-${basename8(dir)}-`));
   const candidateDir = join25(transactionDir, "candidate");
   const backupDir = join25(transactionDir, "backup");
   const candidateSkillMdPath = join25(candidateDir, "SKILL.md");
@@ -19047,7 +19321,7 @@ function exactProfileSelection(spec, profile) {
 }
 
 // src/lib/plugin-projection.ts
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import { posix } from "path";
 var PLUGIN_PROJECTION_MANIFEST = "plugin-projection.json";
 var PLUGIN_PROJECTION_LIMITS = Object.freeze({ files: 1024, bytes: 64 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, metadataBytes: 512 * 1024, registrations: 64, history: 128 });
@@ -19058,7 +19332,7 @@ function pluginNeed(value, message) {
   if (!value)
     pluginRefusal(message);
 }
-var pluginHash = (bytes) => createHash20("sha256").update(bytes).digest("hex");
+var pluginHash = (bytes) => createHash21("sha256").update(bytes).digest("hex");
 function pluginObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -19246,9 +19520,9 @@ function buildPluginProjection(entries) {
 }
 
 // src/lib/plugin-projection-store.ts
-import { createHash as createHash21, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID4 } from "crypto";
 import { constants as constants12, closeSync as closeSync12, fchmodSync as fchmodSync2, fstatSync as fstatSync12, fsyncSync as fsyncSync6, linkSync as linkSync3, lstatSync as lstatSync22, mkdirSync as mkdirSync9, openSync as openSync12, opendirSync as opendirSync4, readSync as readSync9, renameSync as renameSync5, rmdirSync as rmdirSync3, rmSync as rmSync3, unlinkSync as unlinkSync5, writeSync as writeSync3 } from "fs";
-import { dirname as dirname16, isAbsolute as isAbsolute15, join as join29, parse as parse6, resolve as resolve14 } from "path";
+import { dirname as dirname17, isAbsolute as isAbsolute17, join as join29, parse as parse6, resolve as resolve16 } from "path";
 var READ_FLAGS = constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
 var WRITE_FLAGS = constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
 var uid = () => typeof process.getuid === "function" ? BigInt(process.getuid()) : undefined;
@@ -19262,8 +19536,8 @@ function stat(path) {
     return pluginRefusal("Cannot inspect plugin filesystem entry");
   }
 }
-function canonical6(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute15(path) && resolve14(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 && isAbsolute17(path) && resolve16(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -19273,8 +19547,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 = dirname16(path), filesystemRoot = parse6(parent).root;
+  canonical7(path);
+  const result = [], parent = dirname17(path), filesystemRoot = parse6(parent).root;
   let current = filesystemRoot;
   for (const segment of ["", ...parent.slice(filesystemRoot.length).split("/").filter(Boolean)]) {
     if (segment)
@@ -19302,7 +19576,7 @@ function verifyAncestors(chain, identityOnly = true) {
 }
 function privateParent(path) {
   const chain = ancestors(path, true), parent = chain.at(-1);
-  pluginNeed(parent && parent.path === dirname16(path), "Plugin storage parent is unavailable");
+  pluginNeed(parent && parent.path === dirname17(path), "Plugin storage parent is unavailable");
   owner(parent.stat);
   pluginNeed((parent.stat.mode & 0o7777n) === 0o700n, "Plugin storage parent must have mode 0700");
   return chain;
@@ -19588,7 +19862,7 @@ function pluginExecutableDigest(path) {
     const opened = fstatSync12(fd, { bigint: true });
     same3(before, opened);
     fileShape(opened, maximum, "executable");
-    const hash2 = createHash21("sha256"), buffer = new Uint8Array(64 * 1024);
+    const hash2 = createHash22("sha256"), buffer = new Uint8Array(64 * 1024);
     let remaining = Number(opened.size);
     while (remaining > 0) {
       const count = readSync9(fd, buffer, 0, Math.min(buffer.byteLength, remaining), null);
@@ -19646,7 +19920,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" && isAbsolute16(registration.projectPath) && resolve15(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
+    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute18(registration.projectPath) && resolve17(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);
@@ -19654,7 +19928,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(isAbsolute16(value[key].executable) && resolve15(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute18(value[key].executable) && resolve17(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)");
@@ -19799,14 +20073,14 @@ function validatePlan(value) {
   pluginNeed(observedEvidenceDigest(plan.observation) === plan.evidenceDigest, "Plugin receipt observed evidence changed");
   pluginNeed(identityDigest(plan) === plan.planDigest, "Plugin receipt immutable identity changed");
 }
-var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var quote2 = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 var 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"';
 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 root(options) {
   const path = options.storeRoot ?? pluginAdmissionRoot();
-  pluginNeed(isAbsolute16(path) && resolve15(path) === path, "Invalid plugin admission store root");
+  pluginNeed(isAbsolute18(path) && resolve17(path) === path, "Invalid plugin admission store root");
   return path;
 }
 function pluginBindingPath(storeRoot, id) {
@@ -20011,15 +20285,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(isAbsolute17(item.storeRoot) && resolve16(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute19(item.storeRoot) && resolve18(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute17(path) && resolve16(path) === path, "Invalid plugin registry path");
-  for (let at = path;; at = dirname17(at)) {
+  pluginNeed(isAbsolute19(path) && resolve18(path) === path, "Invalid plugin registry path");
+  for (let at = path;; at = dirname18(at)) {
     pluginNeed(!lstatSync23(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
-    if (at === dirname17(at))
+    if (at === dirname18(at))
       break;
   }
 }
@@ -20069,7 +20343,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 = join31(dirname17(path), "cache", market, name);
+    const [name, market] = target.pluginId.split("@"), cacheRoot = join31(dirname18(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");
@@ -20085,7 +20359,7 @@ function hashManagedPluginRegistry(path, managed) {
       pluginNeed(/^(?:[A-Za-z0-9][A-Za-z0-9._+-]*-)?[a-f0-9]{12}$/.test(row.version) && row.installPath === join31(cacheRoot, row.version), "Managed plugin cache path or version is outside its registration");
       const approval = (producer) => {
         pluginText(producer);
-        const digest = `sha256:${basename8(producer)}`;
+        const digest = `sha256:${basename9(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)) {
@@ -20147,39 +20421,39 @@ function captureManagedPluginRegistry(path, managedPlugins) {
 }
 
 // src/lib/claude-marketplace-registry.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { closeSync as closeSync14, constants as constants14, fstatSync as fstatSync14, lstatSync as lstatSync24, openSync as openSync14, readSync as readSync11 } from "fs";
-import { basename as basename9, dirname as dirname18, isAbsolute as isAbsolute18, resolve as resolve17 } from "path";
+import { basename as basename10, dirname as dirname19, isAbsolute as isAbsolute20, resolve as resolve19 } from "path";
 var CLAUDE_MARKETPLACE_REGISTRY_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
-function need6(value, reason) {
+function need7(value, reason2) {
   if (!value)
-    throw new Error(`Claude marketplace registry ${reason}`);
+    throw new Error(`Claude marketplace registry ${reason2}`);
 }
 function absolutePath3(value) {
-  need6(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute18(value) && resolve17(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) && isAbsolute20(value) && resolve19(value) === value, "requires a normalized absolute path");
 }
 var 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;
 function parents2(path) {
   const result = [];
-  for (let at = dirname18(path);; at = dirname18(at)) {
+  for (let at = dirname19(path);; at = dirname19(at)) {
     const stat2 = lstatSync24(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 === dirname18(at))
+    if (at === dirname19(at))
       return result;
   }
 }
 function readRegistry2(path, budget2) {
   absolutePath3(path);
-  need6(basename9(path) === "known_marketplaces.json", "requires known_marketplaces.json");
-  need6(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
+  need7(basename10(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 = lstatSync24(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 = openSync14(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
     const opened = fstatSync14(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) {
@@ -20189,10 +20463,10 @@ function readRegistry2(path, budget2) {
       length += count;
     }
     const after = fstatSync14(fd, { bigint: true }), current = lstatSync24(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 = lstatSync24(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 {
@@ -20212,7 +20486,7 @@ function parse7(text2) {
       at++;
   };
   function string() {
-    need6(text2[at] === '"', "contains invalid JSON");
+    need7(text2[at] === '"', "contains invalid JSON");
     const start = at++;
     while (at < text2.length) {
       const character = text2[at++];
@@ -20223,7 +20497,7 @@ function parse7(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 === "\\")
@@ -20232,7 +20506,7 @@ function parse7(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 === '"')
@@ -20246,17 +20520,17 @@ function parse7(text2) {
           if (object6) {
             space();
             const key = string();
-            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 object6 ? { kind: "object", entries } : { kind: "array", items };
@@ -20268,67 +20542,67 @@ function parse7(text2) {
       }
     numberPattern.lastIndex = at;
     const number = numberPattern.exec(text2);
-    need6(number, "contains invalid JSON");
+    need7(number, "contains invalid JSON");
     at += number[0].length;
     return { kind: "number", value: number[0] };
   }
   const root2 = value(0);
   space();
-  need6(at === text2.length && root2.kind === "object", "requires a JSON object without trailing content");
-  need6(root2.entries.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.rows, "exceeds its marketplace row limit");
+  need7(at === text2.length && root2.kind === "object", "requires a JSON object without trailing content");
+  need7(root2.entries.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.rows, "exceeds its marketplace row limit");
   return root2;
 }
 function exactKeys(value, keys) {
   return value?.kind === "object" && value.entries.length === keys.length && value.entries.every(([key]) => keys.includes(key));
 }
-var field = (object6, key) => object6.entries.find(([name]) => name === key)?.[1];
+var field2 = (object6, key) => object6.entries.find(([name]) => name === key)?.[1];
 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, version = 1) {
   if (!exactKeys(row, ["source", "installLocation", "lastUpdated"])) {
     if (version !== 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")
     absolutePath3(sourceLocation);
-  absolutePath3(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");
+  absolutePath3(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 = parse7(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row);
-  const sha2563 = createHash22("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2563 = createHash23("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
   return { path, hashMode: "claude-marketplace-registry", sha256: sha2563 };
 }
 function captureClaudeMarketplaceRegistryV2(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const value = parse7(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row, 2);
-  const sha2563 = createHash22("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2563 = createHash23("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
   return { path, hashMode: "claude-marketplace-registry-v2", sha256: sha2563 };
 }
 
 // src/lib/codex-hook-discovery-recovery.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 
 // src/lib/codex-hook-additions-review.ts
 var events = { UserPromptSubmit: ["userPromptSubmit", "user_prompt_submit"], SessionStart: ["sessionStart", "session_start"], SubagentStart: ["subagentStart", "subagent_start"] };
@@ -20336,12 +20610,12 @@ var matchedEvents = { ...events, PreToolUse: ["preToolUse", "pre_tool_use"] };
 var proofs = new WeakMap;
 
 // src/lib/codex-hook-discovery-recovery.ts
-var sha4 = (text2) => createHash23("sha256").update(text2).digest("hex");
+var sha4 = (text2) => createHash24("sha256").update(text2).digest("hex");
 var fields = [...CODEX_DISCOVERY_PROJECTION_FIELDS];
 var proofs2 = new WeakMap;
 function assertCodexHookDiscoveryRecovery(binding, witness) {
   const proof = proofs2.get(witness);
-  need5(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha4(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  need6(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha4(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   unchanged2(proof.before);
   unchanged2(proof.current);
   proof.recheckAdditions();
@@ -20350,12 +20624,43 @@ 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;
 }
 
 // src/lib/agent-discovery.ts
-var digest = (text2) => createHash24("sha256").update(text2).digest("hex");
+var DISCOVERY_RUNTIME_COMMANDS = Object.freeze({ gemini: "gemini" });
+var DISCOVERY_ROOT_UNRESOLVED = "DISCOVERY_ROOT_UNRESOLVED";
+function discoveryRootUnresolved(agent, command, detail) {
+  return new Error(`${DISCOVERY_ROOT_UNRESOLVED}: ${agent} discovery cannot resolve its "${command}" executable: ${detail}. The reviewed discovery is unchanged; this is an environment gap, not drift.`);
+}
+function isDiscoveryRootUnresolved(error) {
+  return error instanceof Error && error.message.startsWith(`${DISCOVERY_ROOT_UNRESOLVED}: `);
+}
+var quotedPath = (path) => JSON.stringify(path).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+var realpathOrNull = (path) => {
+  try {
+    return realpathSync11(path);
+  } catch {
+    return null;
+  }
+};
+function discoveryExecutable(agent) {
+  const command = DISCOVERY_RUNTIME_COMMANDS[agent];
+  const found = command ? Bun.which(command) : null;
+  if (!command || !found)
+    return null;
+  const path = resolve20(found), target = realpathOrNull(path);
+  return target === null ? null : { command, path, target };
+}
+function recordedDiscoveryExecutable(agent, recorded) {
+  const command = DISCOVERY_RUNTIME_COMMANDS[agent];
+  if (!command || recorded.command !== command)
+    throw new Error(`Recorded ${agent} discovery executable names another command`);
+  const target = realpathOrNull(recorded.path);
+  return target === null ? null : { command, path: recorded.path, target };
+}
+var digest = (text2) => createHash25("sha256").update(text2).digest("hex");
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -20367,12 +20672,12 @@ function parseConfig(text2, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute19(path) || path.includes("\x00"))
+  if (!isAbsolute21(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
-  for (let cursor = path;; cursor = dirname19(cursor)) {
+  for (let cursor = path;; cursor = dirname20(cursor)) {
     if (lstatSync25(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname19(cursor) === cursor)
+    if (dirname20(cursor) === cursor)
       break;
   }
 }
@@ -20391,7 +20696,7 @@ function projectNativeDiscoveryFields(text2, format, fields2, path) {
   const object6 = format === "yaml" ? parseHermesConfig(text2) : parseConfig(text2, path, format === "toml");
   if (!object6 || typeof object6 !== "object" || Array.isArray(object6))
     throw new Error("Expected native discovery configuration object");
-  return digest(JSON.stringify(Object.fromEntries(fields2.map((field2) => [field2, object6[field2] ?? null]))));
+  return digest(JSON.stringify(Object.fromEntries(fields2.map((field3) => [field3, object6[field3] ?? null]))));
 }
 function isSupersededSettingsProjection(agent, configPath, source) {
   if (agent === "sumi")
@@ -20436,6 +20741,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 sha2563;
   }
+  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 sha2563 = captureClaudeMarketplaceEntry(source.path, source.marketplace, source.plugin, budget2).sha256;
+    if (sha2563 !== source.sha256)
+      throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
+    return sha2563;
+  }
   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");
@@ -20473,7 +20786,7 @@ function absentCodexSkillRoots(binding) {
     throw new Error("Invalid disabled Codex discovery proof");
   if (binding.method !== "reviewed" || controls.every((control) => lstatSync25(control.pluginParent, { throwIfNoEntry: false })))
     return [];
-  const cache = dirname19(dirname19(controls[0].pluginParent)), config = join32(dirname19(dirname19(cache)), "config.toml");
+  const cache = dirname20(dirname20(controls[0].pluginParent)), config = join32(dirname20(dirname20(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
   if (!source || projected(source) !== source.sha256)
     throw new Error("Missing current disabled Codex configuration witness");
@@ -20481,7 +20794,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, root2) {
-  const codex = dirname19(dirname19(cache)), config = Bun.TOML.parse(read2(join32(codex, "config.toml")) ?? "");
+  const codex = dirname20(dirname20(cache)), config = Bun.TOML.parse(read2(join32(codex, "config.toml")) ?? "");
   const hooks = read2(join32(codex, "hooks.json"));
   if (hooks !== null)
     hashNativeJsonControls(hooks);
@@ -20494,7 +20807,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 = dirname19(dirname19(controls[0].pluginParent)), config = join32(dirname19(dirname19(cache)), "config.toml");
+  const cache = dirname20(dirname20(controls[0].pluginParent)), config = join32(dirname20(dirname20(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
   if (!source || projected(source) !== source.sha256)
     throw new Error("Missing current retired Codex configuration witness");
@@ -20511,8 +20824,8 @@ function retiredCodexRoots(binding) {
 function captureRetiredCodexDiscovery(binding, controls, rules) {
   if (binding.agent !== "codex" || binding.method !== "reviewed" || !controls.length)
     return binding;
-  const cache = dirname19(dirname19(controls[0].pluginParent));
-  const candidates = binding.sources.filter((source) => source.path.endsWith(sep8 + ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined && [undefined, "bytes"].includes(source.hashMode)).map((source) => dirname19(dirname19(source.path)));
+  const cache = dirname20(dirname20(controls[0].pluginParent));
+  const candidates = binding.sources.filter((source) => source.path.endsWith(sep8 + ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined && [undefined, "bytes"].includes(source.hashMode)).map((source) => dirname20(dirname20(source.path)));
   const roots = [...new Set(candidates)].filter((root2) => !codexDirectHookSelects(cache, root2) && reviewedRetiredCodexRoot(cache, root2, controls, rules, (path) => read2(path), binding.codexRetiredMaterializations?.roots.includes(root2) ?? false)).sort();
   const parents3 = reviewedCodexPluginCapabilitiesUnchanged(cache, controls, (path) => read2(path), rules) ? [...new Set(controls.map((control) => control.pluginParent))].filter((parent) => !codexDirectHookSelects(cache, parent) && reviewedDisabledCodexPluginParent(cache, parent, controls, rules)).sort() : [];
   const { codexRetiredMaterializations: previous, ...current } = binding;
@@ -20541,7 +20854,7 @@ function absentRetiredClaudeRoots(binding) {
     safe4(root2);
     if (lstatSync25(root2, { throwIfNoEntry: false }))
       continue;
-    const claude = dirname19(dirname19(cache)), settings = join32(claude, "settings.json"), registry = join32(claude, "plugins/installed_plugins.json");
+    const claude = dirname20(dirname20(cache)), settings = join32(claude, "settings.json"), registry = join32(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(registry);
     if (!configSource || !registrySource || projected(configSource) !== configSource.sha256 || projected(registrySource) !== registrySource.sha256)
@@ -20558,7 +20871,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 !== basename10(active) || resolve18(active) !== active || dirname19(active) !== dirname19(root2) || active === root2 || !lstatSync25(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync11(active) !== active)
+    if (rows[0].version !== basename11(active) || resolve20(active) !== active || dirname20(active) !== dirname20(root2) || active === root2 || !lstatSync25(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync11(active) !== active)
       continue;
     const activeManifest = full(join32(active, ".claude-plugin/plugin.json"));
     if (!activeManifest || projected(activeManifest) !== activeManifest.sha256)
@@ -20609,7 +20922,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");
@@ -20637,15 +20950,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 = dirname19(dirname19(proof.plugins[0].pluginParent));
-  const config = join32(dirname19(dirname19(cache)), "config.toml"), home = dirname19(dirname19(dirname19(cache)));
+  const cache = dirname20(dirname20(proof.plugins[0].pluginParent));
+  const config = join32(dirname20(dirname20(cache)), "config.toml"), home = dirname20(dirname20(dirname20(cache)));
   const configSource = binding.sources.find((source) => source.path === config && source.sha256 !== null && (!source.format || source.format === "toml" && source.fields?.includes("plugins")));
   const nativeRoots = NATIVE_SKILL_ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => join32(home, path));
-  if (!configSource || proof.plugins.some((input) => nativeRoots.some((root2) => root2 === input.sourceRoot || root2.startsWith(input.sourceRoot + sep8) || input.sourceRoot.startsWith(root2 + sep8)) || binding.sources.some((source) => basename10(source.path) === "config.toml" && (source.path === input.sourceRoot || source.path.startsWith(input.sourceRoot + sep8)))))
+  if (!configSource || proof.plugins.some((input) => nativeRoots.some((root2) => root2 === input.sourceRoot || root2.startsWith(input.sourceRoot + sep8) || input.sourceRoot.startsWith(root2 + sep8)) || binding.sources.some((source) => basename11(source.path) === "config.toml" && (source.path === input.sourceRoot || source.path.startsWith(input.sourceRoot + sep8)))))
     throw new Error("Native installation input overlaps configuration or loading roots");
-  if (proof.plugins.some((input) => dirname19(dirname19(input.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join32(input.sourceRoot, ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined)))
+  if (proof.plugins.some((input) => dirname20(dirname20(input.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join32(input.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 = read2(path);
@@ -20655,16 +20968,18 @@ function codexInstallationRoots(binding) {
   });
 }
 function assertMarketplaceBinding(binding, source) {
-  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename10(source.path) !== "plugin.json" || !source.path.endsWith(join32(sep8, ".claude-plugin", "plugin.json"))))
+  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename11(source.path) !== "plugin.json" || !source.path.endsWith(join32(sep8, ".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" || basename10(source.path) !== "sumi.json"))
+  if (source.hashMode === "sumi-settings-v1" && (binding.agent !== "sumi" || binding.method !== "reviewed" || basename11(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" || basename10(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" || basename11(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" || basename10(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" || basename11(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 rebindAgentDiscovery(binding, changes) {
   const budget2 = discoveryByteBudget();
@@ -20697,10 +21012,10 @@ function captureDiscoveryPathSources(paths) {
   const budget2 = discoveryByteBudget();
   return paths.map((path) => ({ path, hashMode: "path-bytes", sha256: hashDiscoveryPathFile(path, budget2) }));
 }
-function assertProjectDiscovery(agent, directories, home, canonical7 = resolve18, reviewed) {
-  const homeConfigPath = canonical7(agentDiscoveryConfigPath(home, agent));
+function assertProjectDiscovery(agent, directories, home, canonical8 = resolve20, reviewed) {
+  const homeConfigPath = canonical8(agentDiscoveryConfigPath(home, agent));
   for (const directory of directories) {
-    const isHome = resolve18(directory) === resolve18(home);
+    const isHome = resolve20(directory) === resolve20(home);
     if (agent === "hermes") {
       assertHermesEnvironment(home);
       continue;
@@ -20709,7 +21024,7 @@ function assertProjectDiscovery(agent, directories, home, canonical7 = resolve18
       continue;
     const paths = agent === "claude" ? [...isHome ? [] : [".claude/settings.json"], ".claude/settings.local.json"] : agent === "codex" ? [".codex/config.toml"] : agent === "gemini" ? [".gemini/settings.json"] : agent === "opencode" ? ["opencode.json", "opencode.jsonc", ".opencode/opencode.json", ".opencode/opencode.jsonc"] : agent === "sumi" ? ["sumi.json", "sumi.jsonc", ".sumi/sumi.json", ".sumi/sumi.jsonc"] : [".cursor/hooks.json"];
     for (const suffix of paths) {
-      const path = canonical7(join32(directory, suffix)), raw = read2(path);
+      const path = canonical8(join32(directory, suffix)), raw = read2(path);
       if (raw === null)
         continue;
       const isRootAliasedHomeConfig = agent === "claude" && suffix === ".claude/settings.json" || agent === "codex" && suffix === ".codex/config.toml";
@@ -20725,7 +21040,7 @@ function assertProjectDiscovery(agent, directories, home, canonical7 = resolve18
         const managed = reviewed.sources.flatMap((source) => source.hashMode === "claude-plugin-registry" ? source.managedPlugins ?? [] : []);
         if (exact && projected(exact) === exact.sha256 && managed.length) {
           const bindings = managed.map((item) => readPluginBinding(item.storeRoot, item.bindingId));
-          admittedPlugins = Object.entries(config.enabledPlugins).every(([id, enabled]) => typeof enabled === "boolean" && bindings.some((binding) => binding.target.pluginId === id && binding.target.registrations.some((scope) => scope.scope === "project" && scope.projectPath === canonical7(directory))));
+          admittedPlugins = Object.entries(config.enabledPlugins).every(([id, enabled]) => typeof enabled === "boolean" && bindings.some((binding) => binding.target.pluginId === id && binding.target.registrations.some((scope) => scope.scope === "project" && scope.projectPath === canonical8(directory))));
         }
       }
       if (keys.some((key) => config[key] !== undefined && !(key === "enabledPlugins" && admittedPlugins)) || config.disableAllHooks === true || config.disableBundledSkills === false || config.hooksConfig?.enabled === false || config.permission?.skill !== undefined || config.permissions?.deny?.some((rule) => typeof rule === "string" && /^Skill(?:\(|$)/.test(rule)))
@@ -20733,13 +21048,13 @@ function assertProjectDiscovery(agent, directories, home, canonical7 = resolve18
     }
     if (agent === "sumi")
       for (const name of ["plugin", "plugins"]) {
-        const path = canonical7(join32(directory, ".sumi", name));
+        const path = canonical8(join32(directory, ".sumi", name));
         safe4(path);
         if (lstatSync25(path, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(path).length)
           throw new Error(`NATIVE_SKILL_DRIFT: project Sumi plugins require a dedicated discovery review: ${path}`);
       }
     if (agent === "claude") {
-      const commands = canonical7(join32(directory, ".claude/commands"));
+      const commands = canonical8(join32(directory, ".claude/commands"));
       safe4(commands);
       if (lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length)
         throw new Error("NATIVE_SKILL_DRIFT: legacy project command discovery requires a dedicated format adapter");
@@ -20751,11 +21066,37 @@ function agentDiscoveryConfigPath(home, agent) {
     return sumiConfigPath(home);
   return join32(home, agent === "hermes" ? ".hermes/config.yaml" : agent === "opencode" ? ".config/opencode/opencode.json" : `.${agent}/${agent === "codex" ? "config.toml" : agent === "cursor" ? "hooks.json" : "settings.json"}`);
 }
+function verifyAutomaticDiscoveryClosure(binding, options) {
+  const command = DISCOVERY_RUNTIME_COMMANDS[binding.agent], recorded = options.executable;
+  const onPath = discoveryExecutable(binding.agent);
+  let runtime, gap;
+  if (recorded) {
+    runtime = recordedDiscoveryExecutable(binding.agent, recorded);
+    if (runtime && runtime.target !== recorded.target)
+      throw new Error(`${options.change}: the recorded ${binding.agent} executable now resolves to ${quotedPath(runtime.target)}, not the reviewed ${quotedPath(recorded.target)}`);
+    if (onPath && onPath.target !== recorded.target)
+      throw new Error(`${options.change}: the "${command}" on this process's PATH resolves to ${quotedPath(onPath.target)}, not the reviewed ${quotedPath(recorded.target)}`);
+    if (!runtime)
+      gap = `the recorded executable ${quotedPath(recorded.path)} no longer resolves. Restore it, or review the change with skills hook install`;
+  } else {
+    runtime = onPath;
+    if (!runtime)
+      gap = "it is not on this process's PATH, and the reviewed policy has no recorded executable path. Run with the PATH used for the review, or run skills hook install there to record it";
+  }
+  const current = resolveAgentDiscovery({ home: options.home, agent: binding.agent, canonical: options.canonical, executable: runtime });
+  if (JSON.stringify(current) === JSON.stringify(binding))
+    return;
+  const reviewedWithRuntime = (binding.builtinNames?.length ?? 0) > 0 || binding.sources.some((source) => basename11(source.path) === "package.json");
+  const otherwiseCurrent = current.method === binding.method && JSON.stringify(current.roots) === JSON.stringify(binding.roots) && JSON.stringify(current.directories) === JSON.stringify(binding.directories) && current.sources.every((source) => binding.sources.some((saved) => isDeepStrictEqual7(saved, source)));
+  if (command && gap && runtime === null && reviewedWithRuntime && otherwiseCurrent)
+    throw discoveryRootUnresolved(binding.agent, command, gap);
+  throw new Error(options.change);
+}
 function resolveAgentDiscovery(options) {
-  const canonical7 = options.canonical ?? resolve18, home = resolve18(options.home), agent = options.agent;
+  const canonical8 = options.canonical ?? resolve20, home = resolve20(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 read2(source.path);
@@ -20777,13 +21118,13 @@ function resolveAgentDiscovery(options) {
       unresolved("JSONC configuration requires a supported format adapter");
     for (const root2 of [directory, join32(home, ".claude"), join32(home, ".agents")])
       for (const name of ["skill", "skills"])
-        roots.add(canonical7(join32(root2, name)));
+        roots.add(canonical8(join32(root2, name)));
     if (config.skills !== undefined && (!Array.isArray(config.skills) || config.skills.some((path) => typeof path !== "string")))
       unresolved("skills must be a string array");
     for (const value of config.skills ?? []) {
-      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute19(value) || value.startsWith("~/")))
+      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute21(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
-      roots.add(canonical7(value.startsWith("~/") ? join32(home, value.slice(2)) : value));
+      roots.add(canonical8(value.startsWith("~/") ? join32(home, value.slice(2)) : value));
     }
     for (const key of ["plugin", "plugins"])
       if (config[key] !== undefined && !Array.isArray(config[key]))
@@ -20822,23 +21163,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("~/") ? join32(home, normalized.slice(2)) : resolve18(home, ".hermes", normalized);
+      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join32(home, normalized.slice(2)) : resolve20(home, ".hermes", normalized);
       safe4(path);
       roots.add(path);
     }
   }
   if (agent === "gemini") {
-    const executable2 = Bun.which("gemini");
+    const executable2 = options.executable === undefined ? discoveryExecutable(agent) : options.executable;
     if (executable2) {
       let packageRoot;
-      for (let directory = dirname19(realpathSync11(executable2)), depth = 0;depth < 8; directory = dirname19(directory), depth++) {
+      for (let directory = dirname20(executable2.target), depth = 0;depth < 8; directory = dirname20(directory), depth++) {
         const path = join32(directory, "package.json"), raw = read2(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname19(directory) === directory)
+        if (dirname20(directory) === directory)
           break;
       }
       if (!packageRoot)
@@ -20861,11 +21202,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) => isDeepStrictEqual7(saved, source))) || [...roots].some((root2) => !retained.roots.includes(root2)) || agent === "gemini" && JSON.stringify(retained.builtinNames) !== JSON.stringify(builtinNames))
       unresolved("retained review is missing current runtime discovery coverage");
     return retained;
@@ -20877,15 +21218,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" || basename10(source.path) !== "plugin.json" || !source.path.endsWith(join32(sep8, ".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" || basename11(source.path) !== "plugin.json" || !source.path.endsWith(join32(sep8, ".claude-plugin", "plugin.json")))
         return source;
-      const pluginRoot = dirname19(dirname19(source.path)), hooksPath = join32(pluginRoot, "hooks/hooks.json");
+      const pluginRoot = dirname20(dirname20(source.path)), hooksPath = join32(pluginRoot, "hooks/hooks.json");
       const hookStat = lstatSync25(hooksPath, { throwIfNoEntry: false });
       const text2 = read2(source.path);
       if (text2 === null)
@@ -20900,13 +21241,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 = resolve18(pluginRoot, manifest.hooks);
+        const declaredHookPath = resolve20(pluginRoot, manifest.hooks);
         if (!declaredHookPath.startsWith(pluginRoot + sep8))
           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" };
     });
@@ -20915,7 +21256,7 @@ function resolveAgentDiscovery(options) {
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: unique, ...agent === "gemini" ? { builtinNames } : {} };
   }
   function plugin(root2) {
-    root2 = canonical7(root2);
+    root2 = canonical8(root2);
     safe4(root2);
     const manifestPath = join32(root2, agent === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
     const raw = witness(manifestPath, undefined, undefined, agent === "claude" ? "claude-plugin-manifest-v1" : undefined);
@@ -20938,16 +21279,16 @@ function resolveAgentDiscovery(options) {
     if (agent === "claude")
       roots.add(join32(root2, "skills"));
     for (const value of declared) {
-      const path = resolve18(root2, value);
+      const path = resolve20(root2, value);
       if (path !== root2 && !path.startsWith(root2 + sep8))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep8}SKILL.md`) ? dirname19(path) : path);
+      roots.add(path.endsWith(`${sep8}SKILL.md`) ? dirname20(path) : path);
     }
   }
   if (agent === "claude") {
     const registrations = witness(join32(home, ".claude/plugins/installed_plugins.json"));
     const installed = registrations === null ? {} : parseConfig(registrations, join32(home, ".claude/plugins/installed_plugins.json")).plugins;
-    const commands = canonical7(join32(home, ".claude/commands"));
+    const commands = canonical8(join32(home, ".claude/commands"));
     safe4(commands);
     if (lstatSync25(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync10(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
@@ -20969,7 +21310,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split = id.lastIndexOf("@"), name = id.slice(0, split), marketplace = id.slice(split + 1);
       const market = config.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute19(market.source))
+      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute21(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join32(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -20977,7 +21318,7 @@ function resolveAgentDiscovery(options) {
       const catalog = parseConfig(catalogText, join32(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(resolve18(market.source, matches[0].source.path));
+      plugin(resolve20(market.source, matches[0].source.path));
     }
   } else if (agent === "opencode") {
     if (witness(join32(home, ".config/opencode/opencode.jsonc")) !== null || witness(join32(home, ".config/opencode/config.json")) !== null)
@@ -20985,7 +21326,7 @@ function resolveAgentDiscovery(options) {
     if ((config.plugin?.length ?? 0) > 0 || config.skills?.urls?.length)
       unresolved("external plugin or remote skill source");
     for (const path of config.skills?.paths ?? []) {
-      if (typeof path !== "string" || !isAbsolute19(path))
+      if (typeof path !== "string" || !isAbsolute21(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
@@ -20994,7 +21335,7 @@ function resolveAgentDiscovery(options) {
     if (lstatSync25(localPlugins, { throwIfNoEntry: false }) && readdirSync10(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "sumi") {
-    if ((config.plugin?.length ?? 0) > 0 || (config.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical7(configPath) && source.path !== canonical7(join32(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
+    if ((config.plugin?.length ?? 0) > 0 || (config.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical8(configPath) && source.path !== canonical8(join32(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
       unresolved("external or foreign local plugins require review");
   } else if (agent === "hermes") {
     for (const directory of [join32(home, ".hermes/plugins"), join32(home, ".hermes/hermes-agent")]) {
@@ -21024,13 +21365,13 @@ function resolveAgentDiscovery(options) {
         roots.add(join32(root2, "skills"));
       }
   }
-  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join32(home, ".hermes/plugins"), join32(home, ".hermes/hermes-agent")].map((path) => canonical7(path))) } : {} };
+  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join32(home, ".hermes/plugins"), join32(home, ".hermes/hermes-agent")].map((path) => canonical8(path))) } : {} };
 }
 
 // src/lib/authoring-path.ts
 var NATIVE_DISCOVERY_ROOTS = NATIVE_SKILL_ROOTS.map(([, path]) => path.split("/"));
 function pathParts(path) {
-  return resolve19(path).split(sep9).filter(Boolean);
+  return resolve21(path).split(sep9).filter(Boolean);
 }
 function nativeRootMatch(path) {
   const parts = pathParts(path);
@@ -21044,16 +21385,16 @@ function nativeRootMatch(path) {
   return;
 }
 function physicalPath(path) {
-  let cursor = resolve19(path);
+  let cursor = resolve21(path);
   const suffix = [];
   while (!lstatSync26(cursor, { throwIfNoEntry: false })) {
-    suffix.unshift(basename11(cursor));
-    const parent = dirname20(cursor);
+    suffix.unshift(basename12(cursor));
+    const parent = dirname21(cursor);
     if (parent === cursor)
-      return resolve19(path);
+      return resolve21(path);
     cursor = parent;
   }
-  return resolve19(realpathSync12(cursor), ...suffix);
+  return resolve21(realpathSync12(cursor), ...suffix);
 }
 function contains(root2, path) {
   return path === root2 || path.startsWith(root2 + sep9);
@@ -21061,7 +21402,7 @@ function contains(root2, path) {
 function configuredRoots(home, explicitHome) {
   const homeData = join33(home, ".hasna", "skills");
   const homePolicy = readManagedSkillPolicySnapshot(homeData);
-  const configuredPolicy = !explicitHome && resolve19(getDataDirReadOnly()) !== resolve19(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
+  const configuredPolicy = !explicitHome && resolve21(getDataDirReadOnly()) !== resolve21(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
   const policy = homePolicy ?? configuredPolicy;
   const bridge = policy?.value.bridge;
   if (bridge && (typeof bridge.home !== "string" || physicalPath(bridge.home) !== physicalPath(home))) {
@@ -21100,22 +21441,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 = resolve19(path);
+  const lexical = resolve21(path);
   const physical = physicalPath(lexical);
   const candidates = [lexical, physical];
   let native = candidates.map(nativeRootMatch).find(Boolean);
-  const home = resolve19(options.homeDir ?? homedir6());
+  const home = resolve21(options.homeDir ?? homedir6());
   const defaults = NATIVE_DISCOVERY_ROOTS.map((parts) => join33(home, ...parts));
   defaults.push(join33(home, ".codex/plugins/cache"), join33(home, ".claude/plugins/cache"), join33(home, ".claude/plugins/synced"), join33(home, ".gemini/extensions"));
   for (const root2 of defaults) {
-    if (candidates.some((candidate2) => contains(resolve19(root2), candidate2) || contains(physicalPath(root2), candidate2)))
+    if (candidates.some((candidate2) => contains(resolve21(root2), candidate2) || contains(physicalPath(root2), candidate2)))
       native ??= root2;
   }
   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 root2 of configuredRoots(home, options.homeDir !== undefined)) {
-    if (candidates.some((candidate2) => contains(resolve19(root2), candidate2) || contains(physicalPath(root2), candidate2))) {
+    if (candidates.some((candidate2) => contains(resolve21(root2), candidate2) || contains(physicalPath(root2), candidate2))) {
       throw new Error(`Refusing portable Skills authoring below configured native discovery root: ${lexical}`);
     }
   }
@@ -21263,20 +21604,20 @@ function isSkillCandidate(dir) {
   return existsSync14(join34(dir, "SKILL.md")) || existsSync14(join34(dir, "skill.json")) || existsSync14(join34(dir, "package.json"));
 }
 function physicalImportPath(path) {
-  let ancestor = resolve20(path);
+  let ancestor = resolve22(path);
   const suffix = [];
   while (!existsSync14(ancestor)) {
-    suffix.unshift(basename12(ancestor));
-    ancestor = dirname21(ancestor);
+    suffix.unshift(basename13(ancestor));
+    ancestor = dirname22(ancestor);
   }
   return join34(realpathSync13(ancestor), ...suffix);
 }
 function assertDisjointImportPaths(source, destination) {
   const sourcePath = realpathSync13(source);
   const destinationPath = physicalImportPath(destination);
-  const contains2 = (parent, child) => {
-    const path = relative7(parent, child);
-    return path === "" || !isAbsolute20(path) && path !== ".." && !path.startsWith(`..${sep10}`);
+  const contains2 = (parent, child2) => {
+    const path = relative7(parent, child2);
+    return path === "" || !isAbsolute22(path) && path !== ".." && !path.startsWith(`..${sep10}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -21291,8 +21632,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(basename12(absoluteSource));
-    const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename12(absoluteSource)}')` : ""} matches a bundled official skill.`;
+    const sourceSlug = safeNormalizeName(basename13(absoluteSource));
+    const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename13(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 = join34(resolvePortableSkillsRoot(options, false), skillName);
@@ -21307,7 +21648,7 @@ function portPortableSkill(sourcePath, options = {}) {
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync4(destination, { recursive: true, force: true });
   }
-  mkdirSync10(dirname21(destination), { recursive: true });
+  mkdirSync10(dirname22(destination), { recursive: true });
   copySkillDirectory(absoluteSource, destination);
   const base = {
     ...inferred,
@@ -21557,7 +21898,7 @@ function safeIsDirectory(path) {
   }
 }
 function isSafeRelativePath2(value) {
-  if (!value.trim() || isAbsolute20(value))
+  if (!value.trim() || isAbsolute22(value))
     return false;
   const normalized = normalize4(value).replace(/\\/g, "/");
   return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
@@ -21873,7 +22214,7 @@ function getAllTags(catalog) {
   return Array.from(tagSet).sort();
 }
 // src/lib/run-state.ts
-import { createHash as createHash25, randomBytes } from "crypto";
+import { createHash as createHash26, randomBytes } from "crypto";
 import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync23, readdirSync as readdirSync13, statSync as statSync12, writeFileSync as writeFileSync10 } from "fs";
 import { extname, join as join36, relative as relative8 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
@@ -22000,7 +22341,7 @@ function collectRunArtifacts(context) {
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash25("sha256").update(bytes).digest("hex"),
+      sha256: createHash26("sha256").update(bytes).digest("hex"),
       sizeBytes: stat2.size
     });
   }
@@ -25529,14 +25870,14 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = zod.def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field2 = shape[key]._zod;
-      if (field2.values) {
+      const field3 = shape[key]._zod;
+      if (field3.values) {
         if (!Object.prototype.hasOwnProperty.call(propValues, key)) {
           assignProp(propValues, key, new Set);
         }
-        for (const v of field2.values)
+        for (const v of field3.values)
           propValues[key].add(v);
-        if (field2.optin !== undefined)
+        if (field3.optin !== undefined)
           propValues[key].add(undefined);
       }
     }
@@ -26949,8 +27290,8 @@ function isRecursive(inst, stack) {
     return true;
   stack.add(inst);
   let result = false;
-  const check = (child) => {
-    if (!result && child?._zod && isRecursive(child, stack))
+  const check = (child2) => {
+    if (!result && child2?._zod && isRecursive(child2, stack))
       result = true;
   };
   const def = inst._zod.def;
@@ -37729,11 +38070,11 @@ var objectProcessor = (schema, ctx, _json, params) => {
   }
   const allKeys = new Set(Object.keys(shape));
   const requiredKeys = new Set([...allKeys].filter((key) => {
-    const field2 = def.shape[key];
+    const field3 = def.shape[key];
     if (ctx.io === "input") {
-      return inputOptin(field2) === undefined;
+      return inputOptin(field3) === undefined;
     } else {
-      return field2._zod.optout === undefined;
+      return field3._zod.optout === undefined;
     }
   }));
   if (requiredKeys.size > 0) {
@@ -41419,7 +41760,7 @@ function clone2(value) {
   return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 // src/lib/canonical-json.ts
-import { createHash as createHash26 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -41463,7 +41804,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash26("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash27("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 
 // src/lib/remote-recurring-contract.ts
@@ -42287,17 +42628,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))
@@ -42372,14 +42713,14 @@ function creditCheckoutFailure(value, status, key) {
 }
 
 // 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);
@@ -42424,10 +42765,10 @@ async function readQuoteUnavailableCode(response) {
   let timer;
   let deadlineExceeded = false;
   const expired = Symbol("quote body deadline");
-  const deadline = new Promise((resolve21) => {
+  const deadline = new Promise((resolve23) => {
     timer = setTimeout(() => {
       deadlineExceeded = true;
-      resolve21(expired);
+      resolve23(expired);
       reader.cancel().catch(() => {});
     }, 1500);
   });
@@ -42774,18 +43115,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() {
@@ -43386,13 +43727,13 @@ class RemoteSkillsClient {
     return normalizeUpdatedSincePage(await response.json());
   }
 }
-function requireOptionalString(record8, field2) {
-  if (record8[field2] === undefined)
+function requireOptionalString(record8, field3) {
+  if (record8[field3] === undefined)
     return;
-  if (typeof record8[field2] !== "string") {
-    throw new Error(`Remote payload did not match the expected contract (${field2} must be a string when present)`);
+  if (typeof record8[field3] !== "string") {
+    throw new Error(`Remote payload did not match the expected contract (${field3} must be a string when present)`);
   }
-  return record8[field2];
+  return record8[field3];
 }
 var INVALID_SKILL_VERSION_RESPONSE = "Remote skill version payload did not match the expected contract.";
 function isVersionRecord(value) {
@@ -43730,7 +44071,7 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/revision.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 var REVISION_ID_PATTERN = /^[0-9a-f]{64}$/;
 function revisionIdOf(content) {
   const canonicalContent = {
@@ -43751,15 +44092,15 @@ function revisionIdOf(content) {
     canonicalContent.archiveReason = content.archiveReason ?? null;
     canonicalContent.replacementSlug = content.replacementSlug ?? null;
   }
-  const canonical7 = JSON.stringify(canonicalContent);
-  return createHash27("sha256").update(canonical7).digest("hex");
+  const canonical8 = JSON.stringify(canonicalContent);
+  return createHash28("sha256").update(canonical8).digest("hex");
 }
 function revisionIdOfRecord(record8) {
   return revisionIdOf(record8);
 }
 // src/lib/pull.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, readFileSync as readFileSync26, renameSync as renameSync7, rmSync as rmSync5, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname22, join as join38 } from "path";
+import { dirname as dirname23, join as join38 } from "path";
 
 // src/lib/skill-bundles.ts
 import { createHmac, timingSafeEqual } from "crypto";
@@ -44101,7 +44442,7 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
   try {
     for (const entry of entries) {
       const destination = join38(staging, entry.path);
-      mkdirSync13(dirname22(destination), { recursive: true });
+      mkdirSync13(dirname23(destination), { recursive: true });
       writeFileSync12(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
@@ -44195,7 +44536,7 @@ function splitNameVersion(raw) {
   return version2 ? { name, version: version2 } : { name };
 }
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute21 } from "path";
+import { isAbsolute as isAbsolute23 } from "path";
 
 // src/lib/remote-invitation-recovery.ts
 class InvitationEmailInputError extends Error {
@@ -44293,7 +44634,7 @@ async function requestInvitationEmail(origin, action, input2) {
 }
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
 var failures2 = {
   INVALID_REQUEST: [400, "The publication request is invalid."],
@@ -44340,7 +44681,7 @@ var hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
 var record9 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var exact = (v, keys) => record9(v) && Object.keys(v).sort().join(",") === keys.sort().join(",");
 var date5 = (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));
-var publicationSha256 = (bytes) => createHash28("sha256").update(bytes).digest("hex");
+var publicationSha256 = (bytes) => createHash29("sha256").update(bytes).digest("hex");
 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();
@@ -44585,12 +44926,12 @@ class RemotePrivatePublicationsClient {
       previous = view;
       if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
         return view;
-      await new Promise((resolve21) => {
+      await new Promise((resolve23) => {
         const timer = setTimeout(done, Math.min(1000, until - Date.now()));
         function done() {
           clearTimeout(timer);
           options.signal?.removeEventListener("abort", done);
-          resolve21();
+          resolve23();
         }
         options.signal?.addEventListener("abort", done, { once: true });
       });
@@ -44854,7 +45195,7 @@ var stateSchema = exports_external.object({
 var 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}$/);
 var context = { userId: uuid13.optional(), membershipId: uuid13.optional() };
 var page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-var directory = exports_external.string().max(4096).refine(isAbsolute21, "Use an absolute recovery directory");
+var directory = exports_external.string().max(4096).refine(isAbsolute23, "Use an absolute recovery directory");
 var email4 = exports_external.string().trim().toLowerCase().email().max(254);
 var code = exports_external.string().regex(/^\d{6}$/);
 var recurringSurfaceSchemas = {
@@ -45005,7 +45346,7 @@ function findSkillsParityForMcpTool(tool) {
 }
 // src/lib/registry-sync.ts
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname23, relative as relative9 } from "path";
+import { dirname as dirname24, relative as relative9 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -45062,7 +45403,7 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync14(dirname23(path), { recursive: true });
+  mkdirSync14(dirname24(path), { recursive: true });
   writeFileSync13(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
@@ -46147,14 +46488,14 @@ function clone3(value) {
 }
 // src/lib/feedback.ts
 import { appendFileSync, existsSync as existsSync19, mkdirSync as mkdirSync15 } from "fs";
-import { dirname as dirname24, join as join39 } from "path";
+import { dirname as dirname25, join as join39 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
   return join39(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname24(dbPath);
+  const dir = dirname25(dbPath);
   if (!existsSync19(dir))
     mkdirSync15(dir, { recursive: true });
   const db = new Database(dbPath);
@@ -46183,7 +46524,7 @@ function saveFeedback(input2) {
   const category = input2.category ?? "general";
   if (isApiMode()) {
     const path = join39(getDataDir(), "feedback.jsonl");
-    const dir = dirname24(path);
+    const dir = dirname25(path);
     if (!existsSync19(dir))
       mkdirSync15(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() }) + `
@@ -46206,7 +46547,7 @@ function isApiMode(env = process.env) {
   }
 }
 // src/lib/native-storage.ts
-import { createHash as createHash29, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash30, createHmac as createHmac2 } from "crypto";
 import {
   existsSync as existsSync20,
   mkdirSync as mkdirSync16,
@@ -46215,7 +46556,7 @@ import {
   statSync as statSync13,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname25, join as join40, normalize as normalize5, relative as relative10, sep as sep11 } from "path";
+import { dirname as dirname26, join as join40, normalize as normalize5, relative as relative10, sep as sep11 } from "path";
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
   "skills_sync_cursors"
@@ -46382,7 +46723,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash29("sha256").update(bytes).digest("hex"),
+        sha256: createHash30("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -46407,11 +46748,11 @@ function importSkillsLocalSnapshot(snapshot2, targetDir = process.cwd(), options
       continue;
     }
     const bytes = Buffer.from(file2.contentBase64, "base64");
-    const hash4 = createHash29("sha256").update(bytes).digest("hex");
+    const hash4 = createHash30("sha256").update(bytes).digest("hex");
     if (hash4 !== file2.sha256) {
       throw new Error(`Snapshot file checksum mismatch: ${file2.path}`);
     }
-    mkdirSync16(dirname25(absolutePath4), { recursive: true });
+    mkdirSync16(dirname26(absolutePath4), { recursive: true });
     writeFileSync14(absolutePath4, bytes);
     written += 1;
   }
@@ -46739,7 +47080,7 @@ function toIsoString(value) {
   return Number.isNaN(date6.getTime()) ? value : date6.toISOString();
 }
 function sha256Hex2(value) {
-  return createHash29("sha256").update(value).digest("hex");
+  return createHash30("sha256").update(value).digest("hex");
 }
 function normalizeHeaders(headers) {
   const result = {};
@@ -46791,7 +47132,7 @@ function toArrayBuffer(bytes) {
   return buffer;
 }
 // src/lib/station-snapshot.ts
-import { createHash as createHash30 } from "crypto";
+import { createHash as createHash31 } from "crypto";
 import {
   copyFileSync,
   mkdirSync as mkdirSync17,
@@ -46799,7 +47140,7 @@ import {
   statSync as statSync15,
   writeFileSync as writeFileSync15
 } from "fs";
-import { dirname as dirname26, isAbsolute as isAbsolute22, relative as relative11, resolve as resolve21, sep as sep13 } from "path";
+import { dirname as dirname27, isAbsolute as isAbsolute24, relative as relative11, resolve as resolve23, sep as sep13 } from "path";
 
 // src/lib/portable-snapshot-filter.ts
 import { readdirSync as readdirSync15, statSync as statSync14 } from "fs";
@@ -46966,7 +47307,7 @@ function validateStationId(stationId) {
   }
 }
 function sha256File(filePath) {
-  return createHash30("sha256").update(readFileSync28(filePath)).digest("hex");
+  return createHash31("sha256").update(readFileSync28(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -47037,7 +47378,7 @@ function humanHomes(scanned) {
   }));
 }
 function writeStationSnapshot(options) {
-  const repoRoot = resolve21(options.repoRoot ?? process.cwd());
+  const repoRoot = resolve23(options.repoRoot ?? process.cwd());
   const { scanned, plans, totalBytes } = planStationSnapshot(options);
   const manifestFiles = plans.map((plan) => ({
     relativePath: plan.source.relativePath,
@@ -47063,9 +47404,9 @@ function writeStationSnapshot(options) {
   const conflicts = [];
   const untouched = [];
   for (const plan of plans) {
-    const destination = resolve21(repoRoot, plan.destination);
+    const destination = resolve23(repoRoot, plan.destination);
     const destinationRelative = relative11(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep13) || isAbsolute22(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep13) || isAbsolute24(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -47086,8 +47427,8 @@ function writeStationSnapshot(options) {
   }
   let written = 0;
   for (const plan of untouched) {
-    const destination = resolve21(repoRoot, plan.destination);
-    mkdirSync17(dirname26(destination), { recursive: true });
+    const destination = resolve23(repoRoot, plan.destination);
+    mkdirSync17(dirname27(destination), { recursive: true });
     copyFileSync(plan.source.fullPath, destination);
     written += 1;
   }
@@ -47105,8 +47446,8 @@ function writeStationSnapshot(options) {
     },
     files: manifestFiles
   };
-  const manifestPath = resolve21(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync17(dirname26(manifestPath), { recursive: true });
+  const manifestPath = resolve23(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync17(dirname27(manifestPath), { recursive: true });
   writeFileSync15(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
@@ -47117,7 +47458,7 @@ function writeStationSnapshot(options) {
   };
 }
 // src/lib/station-hydrate.ts
-import { createHash as createHash31 } from "crypto";
+import { createHash as createHash32 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync18,
@@ -47126,7 +47467,7 @@ import {
   statSync as statSync16,
   writeFileSync as writeFileSync16
 } from "fs";
-import { dirname as dirname27, join as join42, resolve as resolve22, sep as sep14 } from "path";
+import { dirname as dirname28, join as join42, resolve as resolve24, sep as sep14 } from "path";
 var STATION_HYDRATION_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-hydration-manifest/v1";
 var STATION_HYDRATION_PRODUCER = { name: "@hasna/skills", version: package_default.version };
 var MANIFEST_HASH_KEY_SEP = String.fromCharCode(0);
@@ -47323,12 +47664,12 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash31("sha256").update(joined.sort().join(`
+  return createHash32("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve22(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve22(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve24(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve24(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -47382,7 +47723,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync18(dirname27(entry.destination), { recursive: true });
+    mkdirSync18(dirname28(entry.destination), { recursive: true });
     copyFileSync2(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -47403,8 +47744,8 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join42(dirname27(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync18(dirname27(hydrationManifestPath), { recursive: true });
+  const hydrationManifestPath = join42(dirname28(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync18(dirname28(hydrationManifestPath), { recursive: true });
   writeFileSync16(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
@@ -47416,19 +47757,19 @@ function writeStationHydration(options) {
 }
 // src/lib/private-publication-recovery.ts
 import { constants as constants15, closeSync as closeSync15, fsyncSync as fsyncSync7, fstatSync as fstatSync15, lstatSync as lstatSync27, mkdirSync as mkdirSync19, openSync as openSync15, readSync as readSync12, realpathSync as realpathSync14, renameSync as renameSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname28, isAbsolute as isAbsolute23, join as join43, resolve as resolve23 } from "path";
+import { dirname as dirname29, isAbsolute as isAbsolute25, join as join43, resolve as resolve25 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 var fail3 = () => {
   throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
 };
 function safeDirectory(directory2) {
-  if (!isAbsolute23(directory2) || directory2 !== resolve23(directory2) || realpathSync14(directory2) !== directory2)
+  if (!isAbsolute25(directory2) || directory2 !== resolve25(directory2) || realpathSync14(directory2) !== directory2)
     return fail3();
-  for (let path = directory2;; path = dirname28(path)) {
+  for (let path = directory2;; path = dirname29(path)) {
     const stat2 = lstatSync27(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink())
       return fail3();
-    if (path === dirname28(path))
+    if (path === dirname29(path))
       break;
   }
   const own2 = lstatSync27(directory2);
@@ -47560,11 +47901,11 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute23(recoveryDirectory) || resolve23(recoveryDirectory) !== recoveryDirectory || realpathSync14(dirname28(recoveryDirectory)) !== dirname28(recoveryDirectory))
+  if (!isAbsolute25(recoveryDirectory) || resolve25(recoveryDirectory) !== recoveryDirectory || realpathSync14(dirname29(recoveryDirectory)) !== dirname29(recoveryDirectory))
     return fail3();
   mkdirSync19(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync15(dirname28(recoveryDirectory), constants15.O_RDONLY | constants15.O_NOFOLLOW);
+  const parent = openSync15(dirname29(recoveryDirectory), constants15.O_RDONLY | constants15.O_NOFOLLOW);
   try {
     fsyncSync7(parent);
   } finally {
@@ -47651,8 +47992,8 @@ async function inspectLocked(client2, directory2, cancel) {
   return privatePublicationResult(directory2, receipt);
 }
 // src/lib/skill-context.ts
-import { createHash as createHash32 } from "crypto";
-import { resolve as resolve24 } from "path";
+import { createHash as createHash33 } from "crypto";
+import { resolve as resolve26 } from "path";
 function words(value) {
   return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
 }
@@ -47691,7 +48032,7 @@ async function buildSkillContext(input2, options = {}) {
   const promptWords = words(prompt);
   const promptNames = new Set(prompt.toLowerCase().match(/[a-z0-9]+(?:-[a-z0-9]+)*/g) ?? []);
   const loaded = new Set(resolved.session?.loaded ?? []);
-  const paths = [...input2.paths ?? [], ...input2.cwd ? [input2.cwd, resolve24(input2.cwd)] : []];
+  const paths = [...input2.paths ?? [], ...input2.cwd ? [input2.cwd, resolve26(input2.cwd)] : []];
   const candidates = profile.selections.map((selection) => {
     const key = selectionKey(selection);
     if (input2.restore && loaded.has(key))
@@ -47718,7 +48059,7 @@ async function buildSkillContext(input2, options = {}) {
   const omitted = [];
   let chars = 0;
   for (const candidate2 of candidates) {
-    const { selection, reason } = candidate2;
+    const { selection, reason: reason2 } = candidate2;
     if (!input2.restore && !explicit.has(selectionKey(selection)) && loaded.has(selectionKey(selection)))
       continue;
     const loadCommand = `skills load ${selection.slug}@${selection.version} --selection-profile ${profile.profileId}`;
@@ -47728,7 +48069,7 @@ async function buildSkillContext(input2, options = {}) {
     }
     const entries = await readSelectedEntries(selection, resolved, resolverOptions);
     const { content } = readSelectedDocument(entries);
-    const section = `Skill ${selection.slug}@${selection.version} (${selection.bundleDigest}; ${reason})
+    const section = `Skill ${selection.slug}@${selection.version} (${selection.bundleDigest}; ${reason2})
 ${content}`;
     if (maxChars !== undefined && chars + section.length + (sections.length ? 2 : 0) > maxChars) {
       omitted.push({ slug: selection.slug, version: selection.version, reason: "context-budget", loadCommand });
@@ -47736,7 +48077,7 @@ ${content}`;
     }
     chars += section.length + (sections.length ? 2 : 0);
     sections.push(section);
-    selections.push({ ...selection, reason });
+    selections.push({ ...selection, reason: reason2 });
     loaded.add(selectionKey(selection));
   }
   const context2 = sections.join(`
@@ -47744,7 +48085,7 @@ ${content}`;
 `);
   const receipt = {
     schemaVersion: 1,
-    id: createHash32("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    id: createHash33("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
     profileId: profile.profileId,
     profileRevision: profile.profileRevision,
     authority: profile.authority,
@@ -47760,9 +48101,9 @@ ${content}`;
   return { context: context2, selections, omitted, receipt };
 }
 // src/lib/session-reconciliation.ts
-import { createHash as createHash33 } from "crypto";
+import { createHash as createHash34 } from "crypto";
 var SESSION_RECONCILIATION_PLAN_TTL_MS = 5 * 60 * 1000;
-var digest3 = (value) => createHash33("sha256").update(JSON.stringify(value)).digest("hex");
+var digest3 = (value) => createHash34("sha256").update(JSON.stringify(value)).digest("hex");
 function exactTimestamp(value) {
   const parsed = value === undefined ? Number.NaN : Date.parse(value);
   if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value) {
@@ -47795,6 +48136,8 @@ function inspectSkillSession(sessionId, options = {}) {
     loadedCount: receipt.loaded.length
   };
 }
+var SESSION_RENEWAL_REFUSAL_TTL_MS = 5 * 60 * 1000;
+var SESSION_RENEWAL_REFUSAL_MAX_BYTES = 4 * 1024;
 async function reconcileSkillSession(input2, options = {}) {
   if (![input2.fromProfile, input2.fromRevision, input2.selectionProfile, input2.profileRevision].every((value) => typeof value === "string" && value.trim()) || !/^[a-f0-9]{64}$/.test(input2.receiptSha256)) {
     throw new SkillSelectionError("INVALID_SESSION_RECONCILIATION", "Name the exact old receipt SHA256, old profile/revision and intended target profile/revision.");
@@ -47982,6 +48325,7 @@ export {
   isPortableWithinSkill,
   isGatewayBackedSkill,
   isExcludedSkillFileName,
+  isDiscoveryRootUnresolved,
   isCodexNativeSkillDisabled,
   isBasicSkillName,
   inventoryNativeSkills,
@@ -47994,6 +48338,7 @@ export {
   inspectPrivatePublication,
   importSkillsLocalSnapshot,
   homePathFor,
+  hashClaudeMarketplaceEntry,
   getToolPrimitive,
   getStorageStatus,
   getStorageDatabaseUrl,
@@ -48078,6 +48423,7 @@ export {
   captureClaudeSettings,
   captureClaudeMarketplaceRegistryV2,
   captureClaudeMarketplaceRegistry,
+  captureClaudeMarketplaceEntry,
   canonicalizeManifest,
   buildSkillsS3ObjectUrl,
   buildSkillsApiUrl,
@@ -48159,9 +48505,11 @@ export {
   InvitationEmailInputError,
   HttpProfileClient,
   HostedApiError,
+  DISCOVERY_ROOT_UNRESOLVED,
   DEFAULT_EXPORT_DIR,
   ContentHashInputError,
   CONTENT_HASH_LIMITS,
+  CLAUDE_MARKETPLACE_ENTRY_HASH_MODE,
   CLAUDE_COORDINATED_HOOK_EVENTS,
   CATEGORIES,
   BASIC_SKILL_NAMES,