@hasna/skills 0.10.92 → 0.10.93

package/bin/index.js

@@ -36888,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.92",
+    version: "0.10.93",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -59021,6 +59021,82 @@ var init_runtime_launcher = __esm(() => {
   PINNED_LAUNCHER_MAX_BYTES = 16 * 1024;
 });
 
+// src/lib/linux-access-acl.ts
+function queryAttribute(probe2, errno, fd, attribute) {
+  for (let attempt2 = 0;attempt2 < LINUX_ACL_QUERY_ATTEMPTS; attempt2++) {
+    errno.set?.(0);
+    const result2 = probe2.fgetxattr(fd, attribute);
+    const code = errno.get();
+    if (result2 !== -1 && result2 !== -1n)
+      return "present";
+    if (code === LINUX_ENODATA)
+      return "absent";
+    if (code === LINUX_EOPNOTSUPP)
+      return "unsupported";
+  }
+  return "unverified";
+}
+function linuxAccessAclAbsent(probe2, fd, creationParent) {
+  if (probe2.arch !== "x64" && probe2.arch !== "arm64")
+    return false;
+  const errno = probe2.errno;
+  if (!errno)
+    return false;
+  let unsupported = false;
+  for (const attribute of ["system.posix_acl_access", ...creationParent ? ["system.posix_acl_default"] : []]) {
+    const state = queryAttribute(probe2, errno, fd, attribute);
+    if (state === "present" || state === "unverified")
+      return false;
+    if (state === "unsupported")
+      unsupported = true;
+  }
+  if (!unsupported)
+    return true;
+  const type = probe2.filesystemType(fd);
+  return type !== null && LINUX_ACL_FREE_WHEN_UNSUPPORTED.has(type);
+}
+function withGlibcAclProbe(use) {
+  try {
+    const { dlopen, ptr, read: read2, FFIType } = __require("bun:ffi");
+    const library = dlopen("libc.so.6", {
+      fgetxattr: { args: ["i32", "ptr", "ptr", "u64"], returns: FFIType.i64_fast },
+      fstatfs: { args: ["i32", "ptr"], returns: "i32" },
+      __errno_location: { args: [], returns: "ptr" }
+    });
+    try {
+      const location = library.symbols.__errno_location();
+      const names = new Map;
+      return use({
+        arch: process.arch,
+        errno: location ? { get: () => read2.i32(location) } : null,
+        fgetxattr: (fd, attribute) => {
+          let name = names.get(attribute);
+          if (!name)
+            names.set(attribute, name = Buffer.from(attribute + "\x00"));
+          return library.symbols.fgetxattr(fd, ptr(name), null, 0);
+        },
+        filesystemType: (fd) => {
+          const statfs = new BigUint64Array(32);
+          return library.symbols.fstatfs(fd, ptr(statfs)) === 0 ? statfs[0] : null;
+        }
+      });
+    } finally {
+      library.close();
+    }
+  } catch {
+    return false;
+  }
+}
+var LINUX_ENODATA = 61, LINUX_EOPNOTSUPP = 95, LINUX_ACL_QUERY_ATTEMPTS = 4, LINUX_ACL_FREE_WHEN_UNSUPPORTED;
+var init_linux_access_acl = __esm(() => {
+  LINUX_ACL_FREE_WHEN_UNSUPPORTED = new Set([
+    0xef53n,
+    0x58465342n,
+    0x9123683en,
+    0x01021994n
+  ]);
+});
+
 // src/lib/retained-review-artifacts.ts
 import { createHash as createHash29 } from "crypto";
 import { constants as constants20, closeSync as closeSync18, fstatSync as fstatSync18, fsyncSync as fsyncSync6, lstatSync as lstatSync30, mkdirSync as mkdirSync9, openSync as openSync18, readSync as readSync14, writeSync as writeSync4 } from "fs";
@@ -60069,28 +60145,7 @@ function hookProjectionRefusal(reason2) {
   throw new Error(`CLAUDE_MANAGED_HOOK_${reason2}`);
 }
 function hasNoLinuxAccessAcl(fd, creationParent) {
-  try {
-    const { dlopen, read: read2, ptr } = __require("bun:ffi");
-    const library = dlopen("libc.so.6", {
-      fgetxattr: { args: ["i32", "ptr", "ptr", "u64"], returns: "i64" },
-      __errno_location: { args: [], returns: "ptr" }
-    });
-    try {
-      const errno = library.symbols.__errno_location();
-      if (!errno)
-        return false;
-      for (const attribute of ["system.posix_acl_access", ...creationParent ? ["system.posix_acl_default"] : []]) {
-        const name = Buffer.from(attribute + "\x00");
-        if (Number(library.symbols.fgetxattr(fd, ptr(name), null, 0)) !== -1 || read2.i32(errno) !== 61)
-          return false;
-      }
-      return true;
-    } finally {
-      library.close();
-    }
-  } catch {
-    return false;
-  }
+  return withGlibcAclProbe((probe2) => linuxAccessAclAbsent(probe2, fd, creationParent));
 }
 function assertNativePathAcl(path, observed, options = {}) {
   if (process.platform !== "darwin" && process.platform !== "linux")
@@ -60938,7 +60993,7 @@ function planCodexPluginNameReconcile(request) {
     pathDenies: [...pathDenies].sort(),
     ...discovery ? { discovery } : {}
   };
-  const plan = planAgentIntegration({ home, dataDir: dataDir3, projectDir, agents: ["codex"], codexNativeCatalog: catalog, codexReconcile: input });
+  const plan = planAgentIntegration({ home, dataDir: dataDir3, projectDir, agents: ["codex"], codexNativeCatalog: catalog, codexReconcile: input, allowRootAliases: aliases.length > 0 });
   assertCodexReconcileScope(plan, { configPath, policyPath, prior, names, remoteIdentities, discovery: discovery ?? savedDiscovery });
   const configChange = plan.changes.find((change) => resolve25(change.path) === configPath);
   const plannedRules = configChange ? Bun.TOML.parse(configChange.after).skills?.config ?? [] : [];
@@ -61227,7 +61282,7 @@ async function applyCodexPluginReconcileUnlocked(plan, options, assertCurrent, a
       const uncertain = (reason2) => new Error(`CODEX_RECONCILE_NATIVE_WRITE_UNCERTAIN: ${reason2}; the policy was not written (private backup: ${backupRoot}); config.toml ${codexConfigStructureEqual(currentText(configChange.path), configChange.after) ? "holds" : "may still receive"} this run's deny rows: ${rows}. Run the reconcile again: it finishes the policy once Codex reports those skills disabled`);
       let result2;
       try {
-        result2 = await rpc.request("config/batchWrite", { edits: [{ keyPath: "skills.config", value: codexSkillRows(configChange.after) ?? [], mergeStrategy: "replace" }], filePath: configChange.path, expectedVersion, reloadUserConfig: true });
+        result2 = await rpc.request("config/batchWrite", { edits: [{ keyPath: "skills.config", value: codexSkillRows(configChange.after) ?? [], mergeStrategy: "replace" }], filePath: nativeConfigPath, expectedVersion, reloadUserConfig: true });
       } catch (error) {
         const refused = error instanceof Error && error.message.startsWith("CODEX_HOOK_TRUST_NATIVE_RPC_REFUSED");
         if (refused && !codexConfigStructureEqual(currentText(configChange.path), configChange.after))
@@ -61238,7 +61293,7 @@ async function applyCodexPluginReconcileUnlocked(plan, options, assertCurrent, a
         nativeVersion = result2.version;
       if (!nativeVersion)
         throw uncertain("Codex answered the config write without a valid config version");
-      if (result2?.status !== "ok" || result2.filePath !== configChange.path)
+      if (result2?.status !== "ok" || result2.filePath !== nativeConfigPath)
         throw new Error("CODEX_RECONCILE_NATIVE_WRITE_OVERRIDDEN: Codex did not confirm a plain user-layer write of the deny rows (another configuration layer may override them)");
       if (!codexConfigStructureEqual(currentText(configChange.path), configChange.after))
         throw new Error("CODEX_RECONCILE_NATIVE_READBACK_FAILED: config.toml after Codex's write differs from the planned configuration");
@@ -61289,7 +61344,7 @@ async function applyCodexPluginReconcileUnlocked(plan, options, assertCurrent, a
         if (layers?.length !== 1 || layers[0].version !== nativeVersion)
           incomplete = "config.toml changed after this run's write, so its deny rows were left in place";
         else {
-          const restored = await rpc.request("config/batchWrite", { edits: [{ keyPath: "skills.config", value: codexSkillRows(configChange.before), mergeStrategy: "replace" }], filePath: configChange.path, expectedVersion: nativeVersion, reloadUserConfig: true });
+          const restored = await rpc.request("config/batchWrite", { edits: [{ keyPath: "skills.config", value: codexSkillRows(configChange.before), mergeStrategy: "replace" }], filePath: nativeConfigPath, expectedVersion: nativeVersion, reloadUserConfig: true });
           if (restored?.status !== "ok" || !codexConfigStructureEqual(currentText(configChange.path), configChange.before))
             incomplete = "Codex did not restore config.toml to its preimage";
         }
@@ -62051,6 +62106,7 @@ var init_agent_integration = __esm(() => {
   init_claude_settings_witness();
   init_codex_hook_trust_files();
   init_runtime_launcher();
+  init_linux_access_acl();
   init_retained_review_artifacts();
   HOOK_EVENTS = ["UserPromptSubmit", "SessionStart", "SubagentStart"];
   ROOTS = NATIVE_SKILL_ROOTS;
@@ -65996,8 +66052,8 @@ function resolveDiscovery(options, exclusion) {
   const configPath = exclusion?.nativeHome === undefined ? agentDiscoveryConfigPath(home, agent) : join46(nativeHome, agent === "codex" ? "config.toml" : "settings.json");
   const configText = witness(configPath, agent === "hermes" ? "yaml" : agent === "codex" ? "toml" : "json", agent === "hermes" ? ["skills", "plugins", "hooks"] : agent === "claude" ? ["enabledPlugins", "extraKnownMarketplaces"] : agent === "codex" ? [...CODEX_DISCOVERY_PROJECTION_FIELDS] : agent === "gemini" ? ["skills", "extensions", "security"] : agent === "opencode" ? ["plugin", "skills"] : agent === "sumi" ? [...SUMI_DISCOVERY_PROJECTION_FIELDS] : ["version"]);
   const config = configText === null ? {} : agent === "hermes" ? parseHermesConfig(configText) : parseConfig(configText, configPath, agent === "codex");
-  const unresolved = (detail) => {
-    throw new Error(`Native discovery is unresolved (${agent}: ${detail}); provide a reviewed --discovery-inputs file`);
+  const unresolved = (detail, source) => {
+    throw new NativeDiscoveryUnresolved(agent, detail, source);
   };
   let opaqueClosureVerified = false;
   const verifyOpaqueClosure = (declarations) => {
@@ -66011,6 +66067,17 @@ function resolveDiscovery(options, exclusion) {
     verifyDiscovery(retained, undefined, undefined, undefined, exclusion?.narrowed, canonical9(configPath));
     opaqueClosureVerified = true;
   };
+  const reviewRemedy = (source, check) => {
+    try {
+      check();
+    } catch (error) {
+      if (error instanceof NativeDiscoveryUnresolved) {
+        error.reviewable = true;
+        error.source ??= source;
+      }
+      throw error;
+    }
+  };
   if (exclusion) {
     if (configText !== null && agent !== "codex" && agent !== "hermes")
       parseNativeJsonObject(configText);
@@ -66082,7 +66149,7 @@ function resolveDiscovery(options, exclusion) {
         unresolved(`non-enumerable ${label} require a current settings review`);
     };
     if (hasHooks)
-      verifyCurrentOpaqueSettings("hooks");
+      reviewRemedy(canonical9(configPath), () => verifyCurrentOpaqueSettings("hooks"));
     if (agent === "claude") {
       if (config.env !== undefined) {
         if (!object6(config.env) || Object.keys(config.env).length > 512)
@@ -66095,7 +66162,7 @@ function resolveDiscovery(options, exclusion) {
         if (hasFunctionHookEnvironment) {
           if (!["0", "1"].includes(config.env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS))
             unresolved("malformed Claude env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS flag");
-          verifyCurrentOpaqueSettings("function-hook environment controls");
+          reviewRemedy(canonical9(configPath), () => verifyCurrentOpaqueSettings("function-hook environment controls"));
         }
       }
       if (config.pluginConfigs !== undefined) {
@@ -66122,7 +66189,7 @@ function resolveDiscovery(options, exclusion) {
         }
         hasPluginConfigs = Object.keys(config.pluginConfigs).length > 0;
         if (hasPluginConfigs)
-          verifyCurrentOpaqueSettings("plugin configurations");
+          reviewRemedy(canonical9(configPath), () => verifyCurrentOpaqueSettings("plugin configurations"));
       }
       if (config.enabledPlugins !== undefined && !object6(config.enabledPlugins))
         unresolved("enabledPlugins must be an object");
@@ -66234,7 +66301,7 @@ function resolveDiscovery(options, exclusion) {
     if (Object.keys(config.enabledPlugins ?? config.plugins ?? config.extensions ?? {}).length > 512)
       unresolved("unbounded native registrations");
     if (hasHooks || hasPluginConfigs || hasFunctionHookEnvironment)
-      verifyOpaqueClosure([]);
+      reviewRemedy(canonical9(configPath), () => verifyOpaqueClosure([]));
   }
   if (options.reviewed && (options.reviewed.version !== 1 || !Array.isArray(options.reviewed.agents) || options.reviewed.agents.some((item) => !item || typeof item !== "object") || new Set(options.reviewed.agents.map((item) => item.agent)).size !== options.reviewed.agents.length))
     throw new Error("Invalid --discovery-inputs version or agents");
@@ -66487,40 +66554,41 @@ function resolveDiscovery(options, exclusion) {
     if (exclusion && Object.keys(manifest).some((key2) => /skill|plugin|hook|marketplace|extension|instruction/i.test(key2) && !["skills", "hooks"].includes(key2)))
       unresolved("unknown plugin discovery controls");
     const hooks = witness(join46(root2, "hooks/hooks.json"));
-    if (manifest.hooks !== undefined || hooks !== null) {
-      if (!exclusion || exclusion.retained?.method !== "reviewed")
-        unresolved("plugin hooks require a separate no-skill-injection review");
-      const required = [manifestPath, ...hooks !== null ? [join46(root2, "hooks/hooks.json")] : []];
-      const scoped2 = agent === "codex" && codex !== undefined ? [] : undefined;
-      if (manifest.hooks !== undefined) {
-        if (scoped2 && manifest.hooks && typeof manifest.hooks === "object" && !Array.isArray(manifest.hooks)) {
-          const inline = codexPluginHookHandlers(manifest.hooks);
-          if (!inline)
-            unresolved("unsupported inline plugin hooks");
-          scoped2.push(inline);
-        } else {
-          if (typeof manifest.hooks !== "string")
-            unresolved("unsupported plugin hooks target");
-          const hook = resolve29(root2, manifest.hooks);
-          if (!hook.startsWith(root2 + sep14))
-            unresolved("plugin hooks target escapes its root");
-          required.push(hook);
-          if (scoped2)
-            scoped2.push(readCodexHookDeclaration(witness(hook), hook));
-        }
-      }
-      if (scoped2 && hooks !== null)
-        scoped2.push(readCodexHookDeclaration(hooks, join46(root2, "hooks/hooks.json")));
-      for (const path of required) {
-        const saved = exclusion.retained.sources.filter((source) => source.path === canonical9(path) && source.sha256 !== null && source.format === undefined && source.fields === undefined);
-        if (saved.length ? saved.some((source) => projected(source, undefined, budget3) !== source.sha256) : !(scoped2 && reviewedInstalledCopy(root2, path, codex)))
-          unresolved("plugin hooks require current independently reviewed sources");
-      }
-      if (scoped2 && scoped2.every((item) => item !== null && item.commands === 0)) {
-        verifyCodexPluginHookClosure(root2, codex, codex.source, new Set(scoped2.flatMap((item) => [...item.servers])), required.map((path) => canonical9(path)));
-      } else
-        verifyOpaqueClosure(required.map((path) => canonical9(path)));
-    }
+    if (manifest.hooks !== undefined || hooks !== null)
+      reviewRemedy(canonical9(hooks !== null ? join46(root2, "hooks/hooks.json") : manifestPath), () => {
+        if (!exclusion || exclusion.retained?.method !== "reviewed")
+          unresolved("plugin hooks require a separate no-skill-injection review");
+        const required = [manifestPath, ...hooks !== null ? [join46(root2, "hooks/hooks.json")] : []];
+        const scoped2 = agent === "codex" && codex !== undefined ? [] : undefined;
+        if (manifest.hooks !== undefined) {
+          if (scoped2 && manifest.hooks && typeof manifest.hooks === "object" && !Array.isArray(manifest.hooks)) {
+            const inline = codexPluginHookHandlers(manifest.hooks);
+            if (!inline)
+              unresolved("unsupported inline plugin hooks");
+            scoped2.push(inline);
+          } else {
+            if (typeof manifest.hooks !== "string")
+              unresolved("unsupported plugin hooks target");
+            const hook = resolve29(root2, manifest.hooks);
+            if (!hook.startsWith(root2 + sep14))
+              unresolved("plugin hooks target escapes its root");
+            required.push(hook);
+            if (scoped2)
+              scoped2.push(readCodexHookDeclaration(witness(hook), hook));
+          }
+        }
+        if (scoped2 && hooks !== null)
+          scoped2.push(readCodexHookDeclaration(hooks, join46(root2, "hooks/hooks.json")));
+        for (const path of required) {
+          const saved = exclusion.retained.sources.filter((source) => source.path === canonical9(path) && source.sha256 !== null && source.format === undefined && source.fields === undefined);
+          if (saved.length ? saved.some((source) => projected(source, undefined, budget3) !== source.sha256) : !(scoped2 && reviewedInstalledCopy(root2, path, codex)))
+            unresolved("plugin hooks require current independently reviewed sources", canonical9(path));
+        }
+        if (scoped2 && scoped2.every((item) => item !== null && item.commands === 0)) {
+          verifyCodexPluginHookClosure(root2, codex, codex.source, new Set(scoped2.flatMap((item) => [...item.servers])), required.map((path) => canonical9(path)));
+        } else
+          verifyOpaqueClosure(required.map((path) => canonical9(path)));
+      });
     const commands = join46(root2, "commands");
     safe6(commands);
     if (agent === "claude" && (manifest.commands !== undefined || lstatSync35(commands, { throwIfNoEntry: false })?.isDirectory() && entries(commands).length))
@@ -66630,7 +66698,7 @@ function resolveDiscovery(options, exclusion) {
     unresolved("native discovery roots exceed their bound");
   return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join46(home, ".hermes/plugins"), join46(home, ".hermes/hermes-agent")].map((path) => canonical9(path))) } : {} };
 }
-var DISCOVERY_RUNTIME_COMMANDS, DISCOVERY_ROOT_UNRESOLVED = "DISCOVERY_ROOT_UNRESOLVED", quotedPath = (path) => JSON.stringify(path).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`), realpathOrNull = (path) => {
+var DISCOVERY_RUNTIME_COMMANDS, DISCOVERY_ROOT_UNRESOLVED = "DISCOVERY_ROOT_UNRESOLVED", NativeDiscoveryUnresolved, quotedPath = (path) => JSON.stringify(path).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`), realpathOrNull = (path) => {
   try {
     return realpathSync12(path);
   } catch {
@@ -66667,6 +66735,18 @@ var init_agent_discovery = __esm(() => {
   init_codex_semantic_cache_witness();
   init_agent_discovery_directories();
   DISCOVERY_RUNTIME_COMMANDS = Object.freeze({ gemini: "gemini" });
+  NativeDiscoveryUnresolved = class NativeDiscoveryUnresolved extends Error {
+    agent;
+    detail;
+    source;
+    reviewable = false;
+    constructor(agent, detail, source) {
+      super(`Native discovery is unresolved (${agent}: ${detail}); provide a reviewed --discovery-inputs file`);
+      this.agent = agent;
+      this.detail = detail;
+      this.source = source;
+    }
+  };
   CLAUDE_CONTROL_WITNESS_MODES = new Set(["claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-settings-v5", "claude-marketplace-registry", "claude-marketplace-registry-v2", "claude-marketplace-entry-v1", "claude-plugin-registry"]);
   CLAUDE_CONTROL_FILES = new Set(["settings.json", "settings.local.json", "installed_plugins.json", "known_marketplaces.json"]);
   ADOPTABLE_SETTINGS_MATCHES = Object.freeze(["exact", "screen-reader-receipt"]);
@@ -66705,6 +66785,11 @@ function physicalPath(path) {
   }
   return resolve30(realpathSync13(cursor), ...suffix);
 }
+function portableAuthoringDiscoveryRefusal(error, destination) {
+  const head2 = `Native discovery is unresolved (${error.agent}: ${error.detail}).${error.source ? ` Checked source: ${error.source}.` : ""}`;
+  const review = `skills hook install --agent ${error.agent} --discovery-inputs <reviewed-file> --apply`;
+  return error.reviewable ? `${head2} Portable Skills authoring stays refused: an unreviewed ${error.agent} hook or plugin option could load skills written to ${destination}. This command takes no --discovery-inputs option; review the current ${error.agent} configuration with ${review}, then retry.` : `${head2} Portable Skills authoring stays refused: Skills cannot list every skill root this ${error.agent} configuration registers, so it cannot rule out ${destination}. This command takes no --discovery-inputs option; correct that ${error.agent} configuration entry, then retry. Where a reviewed discovery binding covers it, record one with ${review}.`;
+}
 function contains2(root2, path) {
   const boundary = root2.endsWith(sep15) ? root2 : root2 + sep15;
   return path === root2 || path.startsWith(boundary);
@@ -66805,11 +66890,18 @@ function assertPortableAuthoringPath(path, options = {}) {
   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.`);
   }
-  const roots = configuredRoots(home, options.homeDir !== undefined);
-  for (const value of selected) {
-    if (physicalPath(value.path) === physicalPath(join47(home, `.${value.agent}`)))
-      continue;
-    roots.push(...resolveAgentDiscoveryExclusionRoots({ home, agent: value.agent, nativeHome: value.path, canonical: physicalPath, executable: null }));
+  const roots = [];
+  try {
+    roots.push(...configuredRoots(home, options.homeDir !== undefined));
+    for (const value of selected) {
+      if (physicalPath(value.path) === physicalPath(join47(home, `.${value.agent}`)))
+        continue;
+      roots.push(...resolveAgentDiscoveryExclusionRoots({ home, agent: value.agent, nativeHome: value.path, canonical: physicalPath, executable: null }));
+    }
+  } catch (error) {
+    if (error instanceof NativeDiscoveryUnresolved)
+      throw new Error(portableAuthoringDiscoveryRefusal(error, lexical));
+    throw error;
   }
   for (const root2 of roots) {
     if (candidates.some((candidate2) => [resolve30(root2), physicalPath(root2)].some((nativeRoot) => contains2(nativeRoot, candidate2) || contains2(candidate2, nativeRoot)))) {
@@ -122461,10 +122553,403 @@ var init_completion = __esm(() => {
   categoryNames = CATEGORIES.map((c) => c);
 });
 
+// src/lib/prepare-skill.ts
+import { createHash as createHash47, randomUUID as randomUUID15 } from "crypto";
+import { chmodSync as chmodSync5, existsSync as existsSync35, lstatSync as lstatSync47, mkdirSync as mkdirSync30, mkdtempSync as mkdtempSync7, readFileSync as readFileSync45, readdirSync as readdirSync27, renameSync as renameSync18, rmSync as rmSync10, writeFileSync as writeFileSync28 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname47, isAbsolute as isAbsolute43, join as join73, relative as relative15, resolve as resolve39, sep as sep21 } from "path";
+function prepareSkill(name, options) {
+  const normalized2 = normalizePortableSkillName(name);
+  if (!new RegExp(SEMVER_PATTERN).test(options.version))
+    throw new Error("--version must be a semantic version, for example 0.2.0.");
+  const path = join73(getPortableSkillsRootReadOnly(options), normalized2);
+  assertPortableAuthoringPath(path, options);
+  const before2 = snapshot2(path);
+  const manifestFile = before2.files.find((file2) => file2.path === "skill.json");
+  if (!manifestFile)
+    throw new Error(`Skill '${normalized2}' needs skill.json. Import the source with skills port first.`);
+  let manifest;
+  try {
+    const parsed = JSON.parse(manifestFile.bytes.toString("utf8"));
+    if (!isRecord9(parsed))
+      throw new Error("not an object");
+    manifest = parsed;
+  } catch {
+    throw new Error("skill.json must contain a JSON object; no files were changed.");
+  }
+  const previousVersion = manifest.version;
+  if (typeof previousVersion !== "string" || !new RegExp(SEMVER_PATTERN).test(previousVersion)) {
+    throw new Error("skill.json must declare its current semantic version before preparation.");
+  }
+  if (manifest.kind !== undefined && manifest.kind !== "instruction" && manifest.kind !== "executable") {
+    throw new Error("skill.json has an invalid kind; correct it before preparation.");
+  }
+  const kind = options.kind ?? manifest.kind;
+  if (kind !== "instruction" && kind !== "executable") {
+    throw new Error("This legacy manifest has no explicit kind. Pass --kind instruction or --kind executable; helper scripts alone do not determine a skill's kind.");
+  }
+  const document3 = before2.files.find((file2) => file2.path === "SKILL.md");
+  const documentKind = document3 ? parseSkillFrontmatter(document3.bytes.toString("utf8"))?.kind : undefined;
+  if (documentKind !== undefined && documentKind !== kind) {
+    throw new Error("SKILL.md kind conflicts with the candidate skill.json kind. Review and align both declarations (or remove the optional frontmatter kind), then prepare again; no files were changed.");
+  }
+  if (manifest.provenance !== undefined && !isRecord9(manifest.provenance))
+    throw new Error("skill.json provenance must be an object.");
+  const provenance = manifest.provenance;
+  const candidate2 = { ...manifest, version: options.version, kind, provenance: { ...provenance } };
+  const staging = mkdtempSync7(join73(tmpdir2(), "skills-prepare-"));
+  try {
+    for (const directory3 of before2.directories)
+      mkdirSync30(join73(staging, directory3), { recursive: true });
+    for (const file2 of before2.files) {
+      const destination = join73(staging, file2.path);
+      mkdirSync30(dirname47(destination), { recursive: true });
+      writeFileSync28(destination, file2.bytes, { mode: file2.mode });
+    }
+    const stagedManifest = join73(staging, "skill.json");
+    writeFileSync28(stagedManifest, `${JSON.stringify(candidate2, null, 2)}
+`);
+    const contentHash = computeContentHash(staging);
+    const changed3 = options.version !== previousVersion || kind !== manifest.kind || contentHash !== provenance?.content_hash;
+    if (changed3 && compareVersions(options.version, previousVersion) <= 0) {
+      throw new Error(`Changed content requires a version greater than ${previousVersion}; pass --version <new-semver>.`);
+    }
+    candidate2.provenance.content_hash = contentHash;
+    const candidateBytes = `${JSON.stringify(candidate2, null, 2)}
+`;
+    writeFileSync28(stagedManifest, candidateBytes);
+    validateRawCandidate(candidate2);
+    validateRuntimeEntrypoint(candidate2, staging);
+    const validation = validatePortableSkillDirectory(normalized2, staging);
+    if (!validation.valid)
+      throw new Error(`Skill '${normalized2}' cannot be prepared:
+${validation.issues.map((issue2) => `${issue2.code}: ${issue2.message}`).join(`
+`)}`);
+    assertPackedCanonicalCoverage(staging);
+    if (snapshot2(path).identity !== before2.identity)
+      throw new Error("Skill changed during preparation; review the draft and run prepare again.");
+    if (changed3 && !options.dryRun) {
+      const temporary = join73(path, `.skill-prepare-${randomUUID15()}.tmp`);
+      try {
+        writeFileSync28(temporary, candidateBytes, { flag: "wx", mode: manifestFile.mode });
+        chmodSync5(temporary, manifestFile.mode);
+        renameSync18(temporary, join73(path, "skill.json"));
+      } finally {
+        rmSync10(temporary, { force: true });
+      }
+    }
+    return { name: normalized2, path, previousVersion, version: options.version, kind, contentHash, changed: changed3, written: changed3 && !options.dryRun, warnings: validation.warnings };
+  } finally {
+    rmSync10(staging, { recursive: true, force: true });
+  }
+}
+function assertPackedCanonicalCoverage(root2) {
+  const canonicalPaths = new Set(collectBundleFiles(root2).map((file2) => file2.rel));
+  const packedPaths = new Set(collectSkillBundleEntries(root2).map((entry) => entry.path));
+  const omitted = [...canonicalPaths].filter((path) => !packedPaths.has(path)).sort();
+  if (omitted.length === 0)
+    return;
+  const rendered = omitted.slice(0, MAX_PACK_PARITY_PATHS).map(escapedRelativePath).join(", ");
+  const suffix = omitted.length > MAX_PACK_PARITY_PATHS ? ` (+${omitted.length - MAX_PACK_PARITY_PATHS} more)` : "";
+  throw new Error(`Skill cannot be prepared because packSkillBundle excludes canonical source path(s): ${rendered}${suffix}. ` + "Rename or remove the excluded source before preparing; no files were changed.");
+}
+function escapedRelativePath(path) {
+  const bounded2 = path.length > MAX_PACK_PARITY_PATH_CHARS - 8 ? `${path.slice(0, MAX_PACK_PARITY_PATH_CHARS - 8)}...` : path;
+  return JSON.stringify(bounded2);
+}
+function validateRuntimeEntrypoint(candidate2, root2) {
+  if (candidate2.kind !== "executable" || !isRecord9(candidate2.runtime))
+    return;
+  const entry = candidate2.runtime.entrypoint;
+  if (typeof entry !== "string")
+    return;
+  const target = resolve39(root2, entry), rel = relative15(root2, target);
+  if (isAbsolute43(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep21}`) || isAbsolute43(rel) || !existsSync35(target) || !lstatSync47(target).isFile()) {
+    throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
+  }
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateRawCandidate(candidate2) {
+  for (const field3 of ["standard", "name", "description", "version"]) {
+    if (typeof candidate2[field3] !== "string" || !candidate2[field3].trim())
+      throw new Error(`skill.json ${field3} is required.`);
+  }
+  for (const field3 of ["displayName", "category"]) {
+    if (candidate2[field3] !== undefined && (typeof candidate2[field3] !== "string" || !candidate2[field3].trim()))
+      throw new Error(`Invalid skill.json ${field3}.`);
+  }
+  if (candidate2.tags !== undefined && (!Array.isArray(candidate2.tags) || candidate2.tags.some((tag) => typeof tag !== "string" || !tag.trim())))
+    throw new Error("Invalid skill.json tags.");
+  const issues = validatePortableManifestContract(candidate2, { strict: true });
+  if (issues.length)
+    throw new Error(`Invalid skill.json: ${issues.map((issue2) => issue2.code).join(", ")}`);
+  validateRuntimeEntrypointCompatibility(candidate2);
+  for (const field3 of ["inputs", "commands"]) {
+    const items = candidate2[field3];
+    if (items === undefined)
+      continue;
+    if (!Array.isArray(items))
+      throw new Error(`skill.json ${field3} must be an array.`);
+    for (const item of items) {
+      if (!isRecord9(item) || typeof item.name !== "string" || !item.name.trim())
+        throw new Error(`Invalid skill.json ${field3} name.`);
+      if (field3 === "inputs" && (typeof item.type !== "string" || !item.type.trim() || item.required !== undefined && typeof item.required !== "boolean"))
+        throw new Error("Invalid skill.json input type or required flag.");
+      if (field3 === "commands") {
+        if (!/^[a-z0-9][a-z0-9._-]*$/.test(item.name))
+          throw new Error("Invalid skill.json command name.");
+        for (const target of ["entry", "command"])
+          if (item[target] !== undefined && (typeof item[target] !== "string" || !item[target].trim()))
+            throw new Error(`Invalid skill.json command ${target}.`);
+        if (!item.entry && !item.command)
+          throw new Error("A skill.json command needs entry or command.");
+        if (item.args !== undefined && (!Array.isArray(item.args) || item.args.some((arg) => typeof arg !== "string")))
+          throw new Error("Invalid skill.json command args.");
+      }
+    }
+  }
+}
+function validateRuntimeEntrypointCompatibility(candidate2) {
+  if (candidate2.kind !== "executable" || !isRecord9(candidate2.runtime))
+    return;
+  const runtime = candidate2.runtime.runtime;
+  const entrypoint = candidate2.runtime.entrypoint;
+  if (typeof runtime !== "string" || typeof entrypoint !== "string")
+    return;
+  const extension = entrypoint.toLowerCase().split(".").pop();
+  if (extension === "py" && runtime !== "python3") {
+    throw new Error("Invalid skill.json: runtime.entrypoint with .py extension requires runtime python3.");
+  }
+}
+function compareVersions(left, right) {
+  const parts = (value) => value.split("+")[0].split(/-(.*)/s).slice(0, 2);
+  const [a, ap] = parts(left), [b, bp] = parts(right);
+  const ac = a.split(".").map(BigInt), bc = b.split(".").map(BigInt);
+  for (let i = 0;i < 3; i++)
+    if (ac[i] !== bc[i])
+      return ac[i] > bc[i] ? 1 : -1;
+  if (ap === undefined || bp === undefined)
+    return ap === bp ? 0 : ap === undefined ? 1 : -1;
+  const aa = ap.split("."), bb = bp.split(".");
+  for (let i = 0;i < Math.max(aa.length, bb.length); i++) {
+    const x = aa[i], y = bb[i];
+    if (x === undefined || y === undefined)
+      return x === y ? 0 : x === undefined ? -1 : 1;
+    if (x === y)
+      continue;
+    const xn = /^\d+$/.test(x), yn = /^\d+$/.test(y);
+    if (xn && yn)
+      return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (xn !== yn)
+      return xn ? -1 : 1;
+    return x > y ? 1 : -1;
+  }
+  return 0;
+}
+function snapshot2(root2) {
+  const rootStat = lstatSync47(root2);
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
+    throw new Error("Skill root must be a real directory, not a symlink.");
+  const files = [], directories = [];
+  const hash7 = createHash47("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
+  let count = 0, bytes = 0;
+  const walk2 = (relative16) => {
+    for (const name of readdirSync27(join73(root2, relative16)).sort()) {
+      if (IGNORED.has(name.toLowerCase()) || !relative16 && ROOT_IGNORED.has(name.toLowerCase()))
+        continue;
+      const path = relative16 ? `${relative16}/${name}` : name;
+      if (++count > 20000)
+        throw new Error("Skill exceeds the preparation entry limit (20000).");
+      const absolute = join73(root2, path), stat3 = lstatSync47(absolute);
+      if (stat3.isSymbolicLink())
+        throw new Error(`Skill contains a symlink: ${path}. No files were changed.`);
+      if (stat3.isDirectory() && name === "node_modules")
+        continue;
+      hash7.update(JSON.stringify([path, stat3.dev, stat3.ino, stat3.mode]));
+      if (stat3.isDirectory()) {
+        directories.push(path);
+        walk2(path);
+      } else if (stat3.isFile()) {
+        bytes += stat3.size;
+        if (bytes > 50000000)
+          throw new Error("Skill exceeds the preparation size limit (50000000 bytes).");
+        const content = readFileSync45(absolute);
+        if (content.length !== stat3.size)
+          throw new Error("Skill changed during preparation.");
+        files.push({ path, bytes: content, mode: stat3.mode & 511 });
+        hash7.update(`\x00${content.length}\x00`).update(content);
+      } else
+        throw new Error(`Unsupported skill entry: ${path}.`);
+      hash7.update("\x00");
+    }
+  };
+  walk2("");
+  return { files, directories, identity: hash7.digest("hex") };
+}
+var MAX_PACK_PARITY_PATHS = 8, MAX_PACK_PARITY_PATH_CHARS = 120, IGNORED, ROOT_IGNORED;
+var init_prepare_skill = __esm(() => {
+  init_portable_skills();
+  init_skill_contract();
+  init_skill_hash();
+  init_skill_bundle();
+  init_skill_validation();
+  init_authoring_path();
+  IGNORED = new Set([".git", ".ds_store", ".system"]);
+  ROOT_IGNORED = new Set(["dist", "build", ".turbo", ".skills-dependency-preparation"]);
+});
+
+// src/cli/commands/portable-skills.ts
+var exports_portable_skills = {};
+__export(exports_portable_skills, {
+  registerPortableSkillCommands: () => registerPortableSkillCommands,
+  AUTHORING_NATIVE_HOOKS_HELP: () => AUTHORING_NATIVE_HOOKS_HELP
+});
+function registerPortableSkillCommands(parent) {
+  parent.command("prepare").argument("<name>", "Name of a skill in the local corpus").requiredOption("--version <version>", "Reviewed semantic version for this draft").option("--kind <kind>", "Explicit instruction or executable kind; required for legacy kind-less manifests").option("--dry-run", "Validate the candidate and report its hash without changing the draft", false).option("--json", "Output result as JSON", false).description("Validate a reviewed draft and update its manifest version and content hash").addHelpText("after", AUTHORING_NATIVE_HOOKS_HELP).action(async (name, options) => {
+    try {
+      const result2 = prepareSkill(name, { ...options, kind: options.kind === undefined ? undefined : parseSkillKind2(options.kind) });
+      if (result2.written)
+        clearRegistryCache();
+      if (options.json)
+        await writeCliOutput(JSON.stringify(result2, null, 2));
+      else {
+        console.log(source_default.green(`${result2.written ? "Prepared" : options.dryRun ? "Previewed" : "Already prepared"} ${result2.name}@${result2.version} (${result2.kind})`));
+        console.log(source_default.dim(`  Content hash: ${result2.contentHash}`));
+        console.log(source_default.dim(`  Manifest: ${result2.path}/skill.json`));
+        if (result2.written)
+          console.log(source_default.dim(`  Publish: skills push ${result2.name}`));
+      }
+    } catch (error61) {
+      if (options.json)
+        await writeCliOutput(JSON.stringify({ error: error61.message }, null, 2));
+      else
+        console.error(source_default.red(error61.message));
+      process.exitCode = 1;
+    }
+  });
+  parent.command("new").alias("scaffold").argument("<name>", "Portable skill name").option("--description <description>", "Short description of what the skill does").option("--kind <kind>", "Skill class: executable (default) or instruction (prose only)", "executable").option("-o, --overwrite", "Replace an existing portable skill folder", false).option("--json", "Output result as JSON", false).description("Scaffold a portable skill under ~/.hasna/skills/installed/<name>").addHelpText("after", AUTHORING_NATIVE_HOOKS_HELP).action((name, options) => {
+    try {
+      const kind = parseSkillKind2(options.kind);
+      const result2 = scaffoldPortableSkill(name, {
+        description: options.description,
+        overwrite: options.overwrite,
+        kind
+      });
+      clearRegistryCache();
+      if (options.json) {
+        console.log(JSON.stringify({ ...result2, manifest: result2.manifest }, null, 2));
+        return;
+      }
+      console.log(source_default.green(`\u2713 Created ${kind} skill '${result2.name}'`));
+      console.log(source_default.dim(`  Path: ${result2.path}`));
+      if (kind === "instruction") {
+        console.log(source_default.dim(`  Edit the prose in: ${result2.path}/SKILL.md`));
+        console.log(source_default.dim(`  Instruction skills are consumed by agents, not run with 'skills run'.`));
+      } else {
+        console.log(source_default.dim(`  Agent instructions: ${result2.path}/AGENTS.md`));
+        console.log(source_default.dim(`  Validate: skills validate ${result2.name}`));
+        console.log(source_default.dim(`  Run: skills run ${result2.name} --help`));
+      }
+    } catch (error61) {
+      writePortableError(error61, options.json);
+    }
+  });
+  parent.command("port").alias("add").argument("<path>", "Existing skill folder (or parent directory with --all) to import").option("--name <name>", "Override the imported skill name").option("--all", "Import every skill subfolder of <path> (bulk import)", false).option("-o, --overwrite", "Replace an existing portable skill folder", false).option("--allow-shadow", "Allow an imported name that shadows a bundled official skill", false).option("--json", "Output result as JSON", false).description("Import an existing skill folder into ~/.hasna/skills/installed/<name>").addHelpText("after", AUTHORING_NATIVE_HOOKS_HELP).action((path, options) => {
+    if (options.all) {
+      handleBulkPort(path, options);
+      return;
+    }
+    try {
+      const result2 = portPortableSkill(path, {
+        name: options.name,
+        overwrite: options.overwrite,
+        allowShadow: options.allowShadow
+      });
+      clearRegistryCache();
+      const validation = validatePortableSkillDirectory(result2.name, result2.path);
+      const payload = { ...result2, valid: validation.valid, issues: validation.issues, warnings: validation.warnings };
+      if (!validation.valid)
+        process.exitCode = 1;
+      if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+      }
+      console.log(validation.valid ? source_default.green(`\u2713 Ported portable skill '${result2.name}'`) : source_default.yellow(`Validation failed for imported files '${result2.name}'; correct the folder before using it.`));
+      console.log(source_default.dim(`  Path: ${result2.path}`));
+      console.log(source_default.dim(`  Valid: ${validation.valid ? "yes" : "no"}`));
+      if (!validation.valid) {
+        for (const issue2 of validation.issues)
+          console.log(source_default.red(`  \u2022 ${issue2.message}`));
+      }
+    } catch (error61) {
+      writePortableError(error61, options.json);
+    }
+  });
+}
+function handleBulkPort(path, options) {
+  if (options.name) {
+    writePortableError(new Error("--name cannot be used with --all"), options.json);
+    return;
+  }
+  try {
+    const summary = portPortableSkillDirectory(path, { overwrite: options.overwrite, allowShadow: options.allowShadow });
+    clearRegistryCache();
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      if (summary.failed > 0)
+        process.exitCode = 1;
+      return;
+    }
+    console.log(source_default.green(`\u2713 Imported ${summary.succeeded}/${summary.total} skill(s) from ${summary.root}`));
+    for (const entry of summary.imported)
+      console.log(source_default.dim(`  \u2022 ${entry.name} \u2192 ${entry.path}`));
+    if (summary.skipped.length > 0) {
+      console.log(source_default.yellow(`  Skipped ${summary.skipped.length}:`));
+      for (const entry of summary.skipped)
+        console.log(source_default.yellow(`  \u2022 ${entry.sourcePath}: ${entry.reason}`));
+      process.exitCode = 1;
+    }
+  } catch (error61) {
+    writePortableError(error61, options.json);
+  }
+}
+function parseSkillKind2(value) {
+  if (value === undefined || value === "executable")
+    return "executable";
+  if (value === "instruction")
+    return "instruction";
+  throw new Error(`Invalid --kind '${value}'. Use 'executable' or 'instruction'.`);
+}
+function writePortableError(error61, json2) {
+  const message = error61.message;
+  if (json2)
+    console.log(JSON.stringify({ error: message }, null, 2));
+  else
+    console.error(source_default.red(message));
+  process.exitCode = 1;
+}
+var AUTHORING_NATIVE_HOOKS_HELP = `
+Native hooks:
+  Authoring refuses while another agent's native hooks, plugin hooks or plugin
+  options are not covered by a current discovery review, because they could
+  load skills from the authoring corpus. The refusal names the agent and the
+  file it checked; review that agent's configuration with
+    skills hook install --agent <agent> --discovery-inputs <reviewed-file> --apply
+  and retry. Authoring commands themselves take no --discovery-inputs option.
+`;
+var init_portable_skills2 = __esm(() => {
+  init_source();
+  init_registry();
+  init_prepare_skill();
+  init_portable_skills();
+});
+
 // src/lib/portable-snapshot-filter.ts
-import { readdirSync as readdirSync27, statSync as statSync23 } from "fs";
+import { readdirSync as readdirSync28, statSync as statSync23 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join73, sep as sep21 } from "path";
+import { join as join74, sep as sep22 } from "path";
 function isExcludedSkillFileName(fileName) {
   if (EXCLUDE_FILE_NAMES.has(fileName)) {
     return true;
@@ -122487,27 +122972,27 @@ function isPortableWithinSkill(relativeParts) {
 function homePathFor(definition, homesRoot) {
   const home = homesRoot ?? homedir12();
   if (definition.subClass === "skills" || definition.subClass === "custom") {
-    return join73(skillsDataRootForHome(home), definition.name);
+    return join74(skillsDataRootForHome(home), definition.name);
   }
   if (definition.agent === "opencode") {
-    return join73(home, ".config", "opencode", "skills");
+    return join74(home, ".config", "opencode", "skills");
   }
-  return join73(home, `.${definition.agent}`, "skills");
+  return join74(home, `.${definition.agent}`, "skills");
 }
 function destinationFor(definition, stationId, relativePath) {
-  const category = definition.subClass === "agent-homes" ? join73("agent-homes", definition.agent ?? "") : definition.name;
-  return join73("resources", stationId, "skills", category, ...relativePath.split(sep21));
+  const category = definition.subClass === "agent-homes" ? join74("agent-homes", definition.agent ?? "") : definition.name;
+  return join74("resources", stationId, "skills", category, ...relativePath.split(sep22));
 }
 function walkEntries(absoluteRoot) {
   let entries;
   try {
-    entries = readdirSync27(absoluteRoot, { withFileTypes: true });
+    entries = readdirSync28(absoluteRoot, { withFileTypes: true });
   } catch {
     return [];
   }
   const output2 = [];
   for (const entry of entries) {
-    const childFull = join73(absoluteRoot, entry.name);
+    const childFull = join74(absoluteRoot, entry.name);
     if (entry.isSymbolicLink()) {
       output2.push({ kind: "symlink", relativePath: entry.name, fullPath: childFull });
       continue;
@@ -122518,7 +123003,7 @@ function walkEntries(absoluteRoot) {
       }
       const nested = walkEntries(childFull);
       for (const item of nested) {
-        output2.push({ ...item, relativePath: join73(entry.name, item.relativePath) });
+        output2.push({ ...item, relativePath: join74(entry.name, item.relativePath) });
       }
       continue;
     }
@@ -122611,22 +123096,22 @@ var init_portable_snapshot_filter = __esm(() => {
 });
 
 // src/lib/station-snapshot.ts
-import { createHash as createHash47 } from "crypto";
+import { createHash as createHash48 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
-  mkdirSync as mkdirSync30,
-  readFileSync as readFileSync45,
+  mkdirSync as mkdirSync31,
+  readFileSync as readFileSync46,
   statSync as statSync24,
-  writeFileSync as writeFileSync28
+  writeFileSync as writeFileSync29
 } from "fs";
-import { dirname as dirname47, isAbsolute as isAbsolute43, relative as relative15, resolve as resolve39, sep as sep22 } from "path";
+import { dirname as dirname48, isAbsolute as isAbsolute44, relative as relative16, resolve as resolve40, sep as sep23 } from "path";
 function validateStationId(stationId) {
   if (!/^[a-z0-9-]+$/.test(stationId)) {
     throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
   }
 }
 function sha256File(filePath) {
-  return createHash47("sha256").update(readFileSync45(filePath)).digest("hex");
+  return createHash48("sha256").update(readFileSync46(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -122634,7 +123119,7 @@ function scanHome(definition, homesRoot) {
   const portable = [];
   const skipped = [];
   for (const entry of entries) {
-    const relativeParts = entry.relativePath.split(sep22);
+    const relativeParts = entry.relativePath.split(sep23);
     const fileName = relativeParts[relativeParts.length - 1];
     if (entry.kind === "symlink") {
       skipped.push({ relativePath: entry.relativePath, reason: "symlink" });
@@ -122697,7 +123182,7 @@ function humanHomes(scanned) {
   }));
 }
 function writeStationSnapshot(options) {
-  const repoRoot = resolve39(options.repoRoot ?? process.cwd());
+  const repoRoot = resolve40(options.repoRoot ?? process.cwd());
   const { scanned, plans, totalBytes } = planStationSnapshot(options);
   const manifestFiles = plans.map((plan) => ({
     relativePath: plan.source.relativePath,
@@ -122723,9 +123208,9 @@ function writeStationSnapshot(options) {
   const conflicts = [];
   const untouched = [];
   for (const plan of plans) {
-    const destination = resolve39(repoRoot, plan.destination);
-    const destinationRelative = relative15(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep22) || isAbsolute43(destinationRelative)) {
+    const destination = resolve40(repoRoot, plan.destination);
+    const destinationRelative = relative16(repoRoot, destination);
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep23) || isAbsolute44(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -122746,8 +123231,8 @@ function writeStationSnapshot(options) {
   }
   let written = 0;
   for (const plan of untouched) {
-    const destination = resolve39(repoRoot, plan.destination);
-    mkdirSync30(dirname47(destination), { recursive: true });
+    const destination = resolve40(repoRoot, plan.destination);
+    mkdirSync31(dirname48(destination), { recursive: true });
     copyFileSync2(plan.source.fullPath, destination);
     written += 1;
   }
@@ -122765,9 +123250,9 @@ function writeStationSnapshot(options) {
     },
     files: manifestFiles
   };
-  const manifestPath = resolve39(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync30(dirname47(manifestPath), { recursive: true });
-  writeFileSync28(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = resolve40(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync31(dirname48(manifestPath), { recursive: true });
+  writeFileSync29(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
     ...base3,
@@ -122798,8 +123283,8 @@ var exports_create_sync_config = {};
 __export(exports_create_sync_config, {
   registerCreateSync: () => registerCreateSync
 });
-import { existsSync as existsSync35 } from "fs";
-import { join as join74 } from "path";
+import { existsSync as existsSync36 } from "fs";
+import { join as join75 } from "path";
 function registerCreateSync(parent) {
   const configCmd = parent.command("config").description("Manage skills configuration");
   configCmd.command("show", { isDefault: true }).option("--json", "Output as JSON", false).description("Show current merged configuration").action((options) => {
@@ -122879,15 +123364,15 @@ function registerCreateSync(parent) {
     const pp = getConfigPath("project");
     if (options.json) {
       console.log(JSON.stringify({
-        global: { path: gp, exists: existsSync35(gp) },
-        project: { path: pp, exists: existsSync35(pp) }
+        global: { path: gp, exists: existsSync36(gp) },
+        project: { path: pp, exists: existsSync36(pp) }
       }, null, 2));
       return;
     }
-    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync35(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
-    console.log(`${source_default.cyan("project")}: ${pp}${existsSync35(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("global")}:  ${gp}${existsSync36(gp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
+    console.log(`${source_default.cyan("project")}: ${pp}${existsSync36(pp) ? source_default.green(" (exists)") : source_default.dim(" (not found)")}`);
   });
-  parent.command("create").argument("<name>", "Skill name (e.g. my-tool)").option("--category <category>", "Skill category", "Development Tools").option("--description <description>", "Short description of what the skill does").option("--kind <kind>", "Skill class: executable or instruction", "executable").option("--tags <tags>", "Comma-separated tags (e.g. api,testing,automation)").option("--global", "Deprecated; custom skills are always global", false).option("--json", "Output result as JSON", false).description("Scaffold a new custom skill directory").action((name, options) => handleCreate(name, options));
+  parent.command("create").argument("<name>", "Skill name (e.g. my-tool)").option("--category <category>", "Skill category", "Development Tools").option("--description <description>", "Short description of what the skill does").option("--kind <kind>", "Skill class: executable or instruction", "executable").option("--tags <tags>", "Comma-separated tags (e.g. api,testing,automation)").option("--global", "Deprecated; custom skills are always global", false).option("--json", "Output result as JSON", false).description("Scaffold a new custom skill directory").addHelpText("after", AUTHORING_NATIVE_HOOKS_HELP).action((name, options) => handleCreate(name, options));
   parent.command("sync").alias("render").option("--selection-profile <id>", "Consume the exact versions selected by an API profile").option("--profile <id>", "Selection profile (alias for --selection-profile; use before sync for credential profile)").option("--project", "Record exact selected versions in this project's lockfile", false).option("--no-station-report", "Verify and activate the selected profile without reporting station state").argument("[names...]", "Skills to sync (default: every skill in this machine's corpus)").option("--for <agent>", `Target one agent (${SYNC_AGENTS.join(", ")}, or all)`, "all").option("--all", "Sync every corpus skill (the default)", false).option("--source <path>", "Canonical corpus source: a directory of skill folders, or a package root with skills/ (overrides $SKILLS_SOURCE)").option("--dry-run", "Show what would be written without touching any agent folder", false).option("--force", "Adopt an unmanaged skill that already has SKILL.md; other unmarked directories are never overwritten", false).option("--check", "Home drift census (missing-from-home / stray-in-home / diverged); exits non-zero on drift, writes nothing", false).option("--adopt", "Unmarked-home adoption mode: hash unmarked home skills against the corpus; exact matches are marked (dry-run by default)", false).option("--prune", "Prune mode: list (or with --apply, remove) marked home skill dirs that have no canonical corpus entry", false).option("--apply", "Write adoption markers / conflicts ledger, or perform prune removals", false).option("--json", "Output as JSON", false).option("--station <id>", "Per-station snapshot mode: snapshot the installed skill homes into resources/<station>/skills with a v3 sync-manifest (dry-run by default; --populate writes)").option("--populate", "Write the per-station snapshot (station mode; the default is dry-run)", false).option("--repo-root <path>", "Station snapshot destination repo root (default: cwd)").option("--homes-root <dir>", "Build the station snapshot from a staged mirror of the skill homes instead of this machine's $HOME").description("Sync an API selection profile into the Skills cache; native migration flags remain available for older installations").action((names, options) => handleSync(names, options));
 }
 function handleCreate(name, options) {
@@ -122909,7 +123394,7 @@ function handleCreate(name, options) {
       console.log(source_default.green(`\u2713 Created custom skill '${result2.name}' at ${result2.path}`));
       console.log(source_default.dim(`  Category: ${result2.manifest.category}`));
       console.log(source_default.dim(`  Tags: ${result2.manifest.tags?.join(", ")}`));
-      console.log(`  ${source_default.cyan("Edit:")} ${join74(result2.path, options.kind === "instruction" ? "SKILL.md" : "src/index.ts")}`);
+      console.log(`  ${source_default.cyan("Edit:")} ${join75(result2.path, options.kind === "instruction" ? "SKILL.md" : "src/index.ts")}`);
       console.log(`  ${source_default.cyan("Prepare:")} skills prepare ${result2.name} --version <new-semver>`);
     }
   } catch (error61) {
@@ -123188,6 +123673,7 @@ var init_create_sync_config = __esm(() => {
   init_config();
   init_auth_store();
   init_portable_skills();
+  init_portable_skills2();
   init_registry();
   init_profile_sync();
   init_managed_policy();
@@ -123198,9 +123684,9 @@ var init_create_sync_config = __esm(() => {
 });
 
 // src/lib/claude-hook-disable.ts
-import { createHash as createHash48, randomUUID as randomUUID15 } from "crypto";
-import { constants as constants32, closeSync as closeSync32, fchownSync as fchownSync2, fchmodSync as fchmodSync4, fsyncSync as fsyncSync11, lstatSync as lstatSync47, mkdirSync as mkdirSync31, openSync as openSync32, realpathSync as realpathSync21 } from "fs";
-import { basename as basename25, dirname as dirname48, isAbsolute as isAbsolute44, join as join75, resolve as resolve40 } from "path";
+import { createHash as createHash49, randomUUID as randomUUID16 } from "crypto";
+import { constants as constants32, closeSync as closeSync32, fchownSync as fchownSync2, fchmodSync as fchmodSync4, fsyncSync as fsyncSync11, lstatSync as lstatSync48, mkdirSync as mkdirSync32, openSync as openSync32, realpathSync as realpathSync21 } from "fs";
+import { basename as basename25, dirname as dirname49, isAbsolute as isAbsolute45, join as join76, resolve as resolve41 } from "path";
 import { KernelLock as KernelLock2 } from "@hasna/contracts/kernel-lock";
 function fail6(reason2) {
   throw new Error(`CLAUDE_HOOK_DISABLE_${reason2}`);
@@ -123213,26 +123699,26 @@ function serialize(value) {
   return value.kind === "string" ? JSON.stringify(value.value) : value.value;
 }
 function path(value) {
-  if (!isAbsolute44(value) || resolve40(value) !== value || /[\x00-\x1f\x7f]/.test(value))
+  if (!isAbsolute45(value) || resolve41(value) !== value || /[\x00-\x1f\x7f]/.test(value))
     fail6("PATH_INVALID");
 }
 function parents3(file2) {
   safeParents(file2);
   const observed = [];
-  for (let directory3 = dirname48(file2);; directory3 = dirname48(directory3)) {
-    const stat3 = lstatSync47(directory3, { bigint: true });
-    assertNativePathAcl(directory3, stat3, { allowDenyOnly: true, creationParent: directory3 === dirname48(file2) });
+  for (let directory3 = dirname49(file2);; directory3 = dirname49(directory3)) {
+    const stat3 = lstatSync48(directory3, { bigint: true });
+    assertNativePathAcl(directory3, stat3, { allowDenyOnly: true, creationParent: directory3 === dirname49(file2) });
     observed.push([directory3, identity6(stat3)]);
-    if (directory3 === dirname48(directory3))
+    if (directory3 === dirname49(directory3))
       break;
   }
   return () => {
     safeParents(file2);
     for (const [directory3, expected] of observed) {
-      const stat3 = lstatSync47(directory3, { bigint: true });
+      const stat3 = lstatSync48(directory3, { bigint: true });
       if (identity6(stat3) !== expected)
         fail6("PARENT_CHANGED");
-      assertNativePathAcl(directory3, stat3, { allowDenyOnly: true, creationParent: directory3 === dirname48(file2) });
+      assertNativePathAcl(directory3, stat3, { allowDenyOnly: true, creationParent: directory3 === dirname49(file2) });
     }
   };
 }
@@ -123240,24 +123726,24 @@ function executable2(command, expectedSha256) {
   path(command);
   if (!digest6(expectedSha256))
     fail6("COMMAND_DIGEST_INVALID");
-  const parentCheck = parents3(command), alias = lstatSync47(command, { bigint: true });
+  const parentCheck = parents3(command), alias = lstatSync48(command, { bigint: true });
   const resolved = resolveLauncherCommand(command);
   if (alias.isSymbolicLink() && directAliasTarget(command) !== resolved.physical)
     fail6("COMMAND_UNVERIFIED");
   const commandFile = snapshot(resolved.physical, false, { readOnlyPackage: true });
   if (commandFile.sha256 !== expectedSha256)
     fail6("COMMAND_CHANGED");
-  const entry = resolved.entry, packageRoot = dirname48(dirname48(entry));
-  if (entry !== join75(packageRoot, "bin", "index.js") || realpathSync21(entry) !== entry)
+  const entry = resolved.entry, packageRoot = dirname49(dirname49(entry));
+  if (entry !== join76(packageRoot, "bin", "index.js") || realpathSync21(entry) !== entry)
     fail6("COMMAND_UNVERIFIED");
   const entryFile = snapshot(entry, false, { readOnlyPackage: true });
-  const manifest = snapshot(join75(packageRoot, "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join76(packageRoot, "package.json"), false, { readOnlyPackage: true });
   const parsed = parseNativeJsonObject(manifest.text);
   if (string6(field3(parsed, "name")) !== "@hasna/skills" || string6(field3(field3(parsed, "bin"), "skills")) !== "bin/index.js")
     fail6("COMMAND_UNVERIFIED");
   return () => {
     parentCheck();
-    const current = lstatSync47(command, { bigint: true });
+    const current = lstatSync48(command, { bigint: true });
     if (movedIdentity(current) !== movedIdentity(alias) || current.ctimeNs !== alias.ctimeNs || alias.isSymbolicLink() && directAliasTarget(command) !== resolved.physical)
       fail6("COMMAND_CHANGED");
     unchanged2(commandFile);
@@ -123310,13 +123796,13 @@ function disableClaudeHooks(options) {
     removed: [],
     settingsWitness: "unchanged"
   };
-  const exists = lstatSync47(options.settings, { throwIfNoEntry: false });
+  const exists = lstatSync48(options.settings, { throwIfNoEntry: false });
   if (!exists) {
     if (options.expectedSettingsSha256 !== "absent" || options.expectedMode !== "absent")
       fail6("TARGET_CHANGED");
     checkCommand();
     checkParents();
-    if (lstatSync47(options.settings, { throwIfNoEntry: false }))
+    if (lstatSync48(options.settings, { throwIfNoEntry: false }))
       fail6("TARGET_CHANGED");
     return base3;
   }
@@ -123379,7 +123865,7 @@ function disableClaudeHooks(options) {
   if (options.preimageDir === options.settings || options.preimageDir.startsWith(options.settings + "/"))
     fail6("PREIMAGE_INVALID");
   const checkPreimageParents = parents3(options.preimageDir);
-  const lock = new KernelLock2(dirname48(options.settings), "skills-claude-hook-disable", { mode: "exclusive" });
+  const lock = new KernelLock2(dirname49(options.settings), "skills-claude-hook-disable", { mode: "exclusive" });
   let exchanged = false, preimage, displaced, receipt;
   try {
     if (!lock.trySync(1000))
@@ -123389,15 +123875,15 @@ function disableClaudeHooks(options) {
     checkParents();
     checkPreimageParents();
     unchanged2(before2);
-    mkdirSync31(options.preimageDir, { mode: 448 });
-    if ((lstatSync47(options.preimageDir).mode & 511) !== 448)
+    mkdirSync32(options.preimageDir, { mode: 448 });
+    if ((lstatSync48(options.preimageDir).mode & 511) !== 448)
       fail6("PREIMAGE_INVALID");
-    preimage = join75(options.preimageDir, "settings.preimage.json");
+    preimage = join76(options.preimageDir, "settings.preimage.json");
     save(preimage, before2.bytes);
     const preserved = snapshot(preimage, true), checkPreservationRoot = parents3(preimage);
     if (preserved.sha256 !== before2.sha256 || !preserved.bytes.equals(before2.bytes))
       fail6("PRESERVATION_FAILED");
-    displaced = join75(dirname48(options.settings), `.settings.skills-disable-${randomUUID15()}.json`);
+    displaced = join76(dirname49(options.settings), `.settings.skills-disable-${randomUUID16()}.json`);
     save(displaced, after2);
     const fd = openSync32(displaced, constants32.O_RDONLY | constants32.O_NOFOLLOW);
     try {
@@ -123411,7 +123897,7 @@ function disableClaudeHooks(options) {
     assertNativePathAcl(displaced, staged.stat);
     if (staged.sha256 !== result2.plannedAfterSha256)
       fail6("STAGING_CHANGED");
-    receipt = join75(options.preimageDir, "receipt.json");
+    receipt = join76(options.preimageDir, "receipt.json");
     const preparationBytes = `${JSON.stringify({
       ...result2,
       state: "prepared",
@@ -123447,14 +123933,14 @@ function disableClaudeHooks(options) {
     unchanged2(preserved);
     if (movedIdentity(displacedOriginal.stat) !== movedIdentity(before2.stat) || displacedOriginal.sha256 !== before2.sha256 || movedIdentity(current.stat) !== movedIdentity(staged.stat) || current.sha256 !== staged.sha256)
       fail6("POST_WRITE_CHANGED");
-    const directory3 = openSync32(dirname48(options.settings), constants32.O_RDONLY | constants32.O_DIRECTORY);
+    const directory3 = openSync32(dirname49(options.settings), constants32.O_RDONLY | constants32.O_DIRECTORY);
     try {
       fsyncSync11(directory3);
     } finally {
       closeSync32(directory3);
     }
     const applied = { ...result2, state: "applied", mutationOccurred: true, afterSha256: staged.sha256, preimage, displaced, receipt };
-    const completed = join75(options.preimageDir, "completed.json");
+    const completed = join76(options.preimageDir, "completed.json");
     const completionBytes = `${JSON.stringify({ ...applied, receipt: completed })}
 `;
     save(completed, completionBytes);
@@ -123486,7 +123972,7 @@ function disableClaudeHooks(options) {
     }
   }
 }
-var hash7 = (text5) => createHash48("sha256").update(text5).digest("hex"), digest6 = (value) => /^[a-f0-9]{64}$/.test(value), events3, object12 = (value) => value?.kind === "object" ? value : undefined, field3 = (value, key2) => object12(value)?.entries.find(([name]) => name === key2)?.[1], string6 = (value) => value?.kind === "string" ? value.value : undefined, identity6 = (stat3) => `${stat3.dev}:${stat3.ino}:${stat3.uid}:${stat3.gid}:${stat3.mode}`, movedIdentity = (stat3) => `${identity6(stat3)}:${stat3.nlink}:${stat3.size}:${stat3.mtimeNs}`;
+var hash7 = (text5) => createHash49("sha256").update(text5).digest("hex"), digest6 = (value) => /^[a-f0-9]{64}$/.test(value), events3, object12 = (value) => value?.kind === "object" ? value : undefined, field3 = (value, key2) => object12(value)?.entries.find(([name]) => name === key2)?.[1], string6 = (value) => value?.kind === "string" ? value.value : undefined, identity6 = (stat3) => `${stat3.dev}:${stat3.ino}:${stat3.uid}:${stat3.gid}:${stat3.mode}`, movedIdentity = (stat3) => `${identity6(stat3)}:${stat3.nlink}:${stat3.size}:${stat3.mtimeNs}`;
 var init_claude_hook_disable = __esm(() => {
   init_agent_adapters();
   init_claude_settings_witness();
@@ -123497,8 +123983,8 @@ var init_claude_hook_disable = __esm(() => {
 });
 
 // src/lib/agent-install-selection.ts
-import { lstatSync as lstatSync48 } from "fs";
-import { dirname as dirname49, join as join76, resolve as resolve41 } from "path";
+import { lstatSync as lstatSync49 } from "fs";
+import { dirname as dirname50, join as join77, resolve as resolve42 } from "path";
 import { homedir as homedir13 } from "os";
 function detectedIntegrationAgents(options = {}) {
   const home = options.home ?? homedir13(), env3 = options.env ?? process.env;
@@ -123511,7 +123997,7 @@ function detectedIntegrationAgents(options = {}) {
     throw new Error("Invalid existing bridge agent inventory");
   const present2 = (path2) => {
     try {
-      return lstatSync48(path2, { throwIfNoEntry: false }) !== undefined;
+      return lstatSync49(path2, { throwIfNoEntry: false }) !== undefined;
     } catch {
       throw new Error("Agent presence cannot be inspected; review native configuration before hook installation");
     }
@@ -123521,13 +124007,13 @@ function detectedIntegrationAgents(options = {}) {
       return true;
     if (agent === "sumi") {
       const xdg = env3.XDG_CONFIG_HOME;
-      const xdgSumi = xdg?.trim() ? resolve41(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve41(home, xdg.slice(2)) : xdg, "sumi") : null;
-      return ["SUMI_HOME", "SUMI_CONFIG_DIR", "SUMI_CONFIG", "SUMI_CONFIG_CONTENT"].some((key2) => env3[key2] !== undefined) || Bun.which("sumi-paths", { PATH: env3.PATH ?? "" }) !== null || NATIVE_SKILL_ROOTS.some(([provider, root2]) => provider === "sumi" && present2(join76(home, dirname49(root2)))) || present2(join76(home, ".config", "sumi")) || xdgSumi !== null && present2(xdgSumi);
+      const xdgSumi = xdg?.trim() ? resolve42(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve42(home, xdg.slice(2)) : xdg, "sumi") : null;
+      return ["SUMI_HOME", "SUMI_CONFIG_DIR", "SUMI_CONFIG", "SUMI_CONFIG_CONTENT"].some((key2) => env3[key2] !== undefined) || Bun.which("sumi-paths", { PATH: env3.PATH ?? "" }) !== null || NATIVE_SKILL_ROOTS.some(([provider, root2]) => provider === "sumi" && present2(join77(home, dirname50(root2)))) || present2(join77(home, ".config", "sumi")) || xdgSumi !== null && present2(xdgSumi);
     }
     if (agent === "hermes" && env3.HERMES_HOME !== undefined)
       return true;
     const adapter = AGENT_ADAPTERS[agent];
-    return present2(join76(home, dirname49(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root2]) => provider === agent && dirname49(root2) === `.${agent}` && present2(join76(home, dirname49(root2))));
+    return present2(join77(home, dirname50(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root2]) => provider === agent && dirname50(root2) === `.${agent}` && present2(join77(home, dirname50(root2))));
   });
   if (!selected.length && !options.allowEmpty)
     throw new Error(`No configured or detected agents; select --agent <agent> explicitly (${INTEGRATION_AGENTS.join(", ")}).`);
@@ -123541,11 +124027,11 @@ var init_agent_install_selection = __esm(() => {
 });
 
 // src/lib/codex-hook-trust-identity.ts
-import { lstatSync as lstatSync49, realpathSync as realpathSync22 } from "fs";
-import { dirname as dirname50, isAbsolute as isAbsolute45, join as join77, resolve as resolve42 } from "path";
+import { lstatSync as lstatSync50, realpathSync as realpathSync22 } from "fs";
+import { dirname as dirname51, isAbsolute as isAbsolute46, join as join78, resolve as resolve43 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual20 } from "util";
 function commandPhysical(command) {
-  need8(typeof command === "string" && isAbsolute45(command) && !command.includes("\x00") && resolve42(command) === command, COMMAND_NOT_CANONICAL);
+  need8(typeof command === "string" && isAbsolute46(command) && !command.includes("\x00") && resolve43(command) === command, COMMAND_NOT_CANONICAL);
   const physical = realpathSync22(command);
   let spelled;
   try {
@@ -123556,7 +124042,7 @@ function commandPhysical(command) {
   safeParents(spelled);
   let direct = false;
   try {
-    const leaf = lstatSync49(spelled);
+    const leaf = lstatSync50(spelled);
     direct = leaf.isSymbolicLink() ? trustedAncestorOwner(leaf.uid) && directAliasTarget(spelled) === physical : spelled === physical;
   } catch {}
   need8(direct, COMMAND_ALIAS_UNSAFE);
@@ -123568,7 +124054,7 @@ function assertPinnedRuntime(runtime) {
   } catch {
     need8(false, "SKILLS_LAUNCHER_UNVERIFIED");
   }
-  need8(resolve42(runtime) === runtime, "SKILLS_LAUNCHER_UNVERIFIED");
+  need8(resolve43(runtime) === runtime, "SKILLS_LAUNCHER_UNVERIFIED");
   safeParents(runtime);
 }
 function skillsCommandTarget(command) {
@@ -123600,12 +124086,12 @@ function targetUnchanged(command, target) {
     assertPinnedRuntime(target.runtime);
 }
 function inspectRecordedSkillsCli(command, expected) {
-  need8(isAbsolute45(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
+  need8(isAbsolute46(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
   const target = skillsCommandTarget(command), resolved = target.entry;
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join77(dirname50(dirname50(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join78(dirname51(dirname51(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need8(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join77(dirname50(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need8(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join78(dirname51(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   need8((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   const receipt = { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 };
   need8(isDeepStrictEqual20(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
@@ -123619,16 +124105,16 @@ function bindSkillsCli(command, reviewed) {
   const normal = Bun.which("skills", { PATH: process.env.PATH });
   need8(normal, "SKILLS_COMMAND_UNAVAILABLE");
   const normalTarget = skillsCommandTarget(normal), resolved = normalTarget.entry;
-  const bound = isAbsolute45(command) ? command : command === "skills" ? normal : undefined;
+  const bound = isAbsolute46(command) ? command : command === "skills" ? normal : undefined;
   need8(bound, "SKILLS_COMMAND_MISMATCH");
   const boundTarget = skillsCommandTarget(bound);
   need8(boundTarget.entry === resolved, "SKILLS_COMMAND_MISMATCH");
   const entrypoint = reviewed?.path ?? process.argv[1];
   need8(entrypoint && realpathSync22(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join77(dirname50(dirname50(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join78(dirname51(dirname51(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need8(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join77(dirname50(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need8(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join78(dirname51(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   if (reviewed)
     need8(/^[a-f0-9]{64}$/.test(reviewed.sha256) && reviewed.sha256 === cli.sha256 && reviewed.version === pkg.version, "SKILLS_RELEASE_MISMATCH");
   need8((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
@@ -123647,7 +124133,7 @@ function captureSkillsCliProducerIdentity(command) {
   const bound = bindSkillsCli(command);
   const target = skillsCommandTarget(command);
   const cli = snapshot(target.entry, false, { readOnlyPackage: true });
-  const manifest = snapshot(join77(dirname50(dirname50(target.entry)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join78(dirname51(dirname51(target.entry)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
   need8(pkg.name === "@hasna/skills" && pkg.version === bound.receipt.version && target.entry === bound.receipt.path, "SKILLS_PACKAGE_MISMATCH");
   const launcher = target.launcher ?? cli;
@@ -123701,23 +124187,23 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync50, mkdirSync as mkdirSync32, readdirSync as readdirSync28, readFileSync as readFileSync46, realpathSync as realpathSync23, statSync as statSync25 } from "fs";
-import { createHash as createHash49, randomUUID as randomUUID16 } from "crypto";
+import { lstatSync as lstatSync51, mkdirSync as mkdirSync33, readdirSync as readdirSync29, readFileSync as readFileSync47, realpathSync as realpathSync23, statSync as statSync25 } from "fs";
+import { createHash as createHash50, randomUUID as randomUUID17 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
-import { dirname as dirname51, isAbsolute as isAbsolute46, join as join78, resolve as resolve43 } from "path";
+import { dirname as dirname52, isAbsolute as isAbsolute47, join as join79, resolve as resolve44 } from "path";
 import { homedir as homedir14 } from "os";
 import { isDeepStrictEqual as isDeepStrictEqual22 } from "util";
 function verifyReleaseArtifact(proof, skillsCli) {
-  need8(isAbsolute46(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  need8(isAbsolute47(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarPath = realpathSync23(proof.packageTarPath);
   need8(statSync25(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
-  const tarBytes = readFileSync46(tarPath);
-  need8(tarBytes.byteLength === proof.packageTarBytes && createHash49("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
-  const packageRoot = dirname51(dirname51(realpathSync23(skillsCli.receipt.path)));
-  const manifest = readFileSync46(join78(packageRoot, "package.json"));
-  need8(createHash49("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
-  need8(createHash49("sha256").update(readFileSync46(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
-  const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync46(skillsCli.receipt.path)]];
+  const tarBytes = readFileSync47(tarPath);
+  need8(tarBytes.byteLength === proof.packageTarBytes && createHash50("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
+  const packageRoot = dirname52(dirname52(realpathSync23(skillsCli.receipt.path)));
+  const manifest = readFileSync47(join79(packageRoot, "package.json"));
+  need8(createHash50("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
+  need8(createHash50("sha256").update(readFileSync47(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
+  const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync47(skillsCli.receipt.path)]];
   for (const [member, expected] of members2) {
     let actual;
     try {
@@ -123731,26 +124217,26 @@ function verifyReleaseArtifact(proof, skillsCli) {
 async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc) {
   let rpc;
   try {
-    const home = resolve43(options.home ?? homedir14()), dataDir3 = resolve43(options.dataDir ?? getDataDirReadOnly());
-    const parent = resolve43(join78(dataDir3, "native-hook-trust")), journal = resolve43(options.journal);
+    const home = resolve44(options.home ?? homedir14()), dataDir3 = resolve44(options.dataDir ?? getDataDirReadOnly());
+    const parent = resolve44(join79(dataDir3, "native-hook-trust")), journal = resolve44(options.journal);
     need8(journal.startsWith(parent + "/") && /^[a-f0-9-]{36}$/.test(journal.slice(parent.length + 1)), "RECONCILE_JOURNAL_PATH");
-    const dir = lstatSync50(journal, { throwIfNoEntry: false });
+    const dir = lstatSync51(journal, { throwIfNoEntry: false });
     need8(!!dir && dir.isDirectory() && !dir.isSymbolicLink() && dir.uid === process.getuid() && (dir.mode & 511) === 448, "UNSAFE_JOURNAL");
-    need8(!lstatSync50(join78(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
-    need8(lstatSync50(join78(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
-    const stoppedFile = snapshot(join78(journal, "stopped.json"), true);
-    const intentFile = snapshot(join78(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
-    const configBefore = snapshot(join78(journal, "config.before.toml"), true), hooksBefore = snapshot(join78(journal, "hooks.before.json"), true), policyBefore = snapshot(join78(journal, "policy.before.json"), true);
+    need8(!lstatSync51(join79(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
+    need8(lstatSync51(join79(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
+    const stoppedFile = snapshot(join79(journal, "stopped.json"), true);
+    const intentFile = snapshot(join79(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
+    const configBefore = snapshot(join79(journal, "config.before.toml"), true), hooksBefore = snapshot(join79(journal, "hooks.before.json"), true), policyBefore = snapshot(join79(journal, "policy.before.json"), true);
     const legacyIntent = intent.home === undefined && intent.configSha256 === undefined && intent.configVersion === undefined && intent.declarations === undefined && intent.admitted === undefined && intent.nativeHooks === undefined;
     need8(intent.version === 1 && /^[a-f0-9]{64}$/.test(intent.planDigest) && typeof intent.configPath === "string" && /^[a-f0-9]{64}$/.test(intent.policySha256) && /^[a-f0-9]{64}$/.test(intent.hooksSha256) && Array.isArray(intent.hooks) && intent.hooks.length > 0 && intent.hooks.length <= 100 && (legacyIntent || typeof intent.home === "string" && intent.home === home && /^[a-f0-9]{64}$/.test(intent.configSha256) && typeof intent.configVersion === "string" && Array.isArray(intent.declarations) && Array.isArray(intent.admitted) && Array.isArray(intent.nativeHooks)), "RECONCILE_INTENT_INVALID");
-    const declarations = intent.declarations ?? intent.hooks.map((hook) => ({ event: hook.event, key: `${join78(home, ".codex/hooks.json")}${hook.key.slice(hook.key.indexOf(".codex/hooks.json") + ".codex/hooks.json".length)}`, command: hook.command }));
+    const declarations = intent.declarations ?? intent.hooks.map((hook) => ({ event: hook.event, key: `${join79(home, ".codex/hooks.json")}${hook.key.slice(hook.key.indexOf(".codex/hooks.json") + ".codex/hooks.json".length)}`, command: hook.command }));
     const admitted = intent.admitted ?? intent.hooks;
     const configSha256 = intent.configSha256 ?? configBefore.sha256, configVersion = intent.configVersion ?? intent.expectedVersion;
     const digestInput = { version: 1, home: intent.home ?? home, configPath: intent.configPath, ...intent.nativeConfigPath !== undefined ? { nativeConfigPath: intent.nativeConfigPath } : {}, configSha256, configVersion, policySha256: intent.policySha256, hooksSha256: intent.hooksSha256, skillsCli: intent.skillsCli, nativeVersion: intent.nativeVersion, declarations, admitted };
     need8(makePlanDigest(digestInput) === intent.planDigest, "RECONCILE_PLAN_CHANGED");
     need8(isDeepStrictEqual22(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
     need8(configBefore.sha256 === (intent.beforeSha256 ?? intent.configSha256) && hooksBefore.sha256 === intent.hooksSha256 && policyBefore.sha256 === intent.policySha256, "RECONCILE_JOURNAL_CHANGED");
-    const policyCurrent = snapshot(join78(dataDir3, "agent-policy.json"), true);
+    const policyCurrent = snapshot(join79(dataDir3, "agent-policy.json"), true);
     const { claudeDiscoveryRecovery: claudeRecovery, nativeHookAdditionsRecovery: additionsRecovery } = options;
     const recovery = claudeRecovery ?? additionsRecovery;
     need8(!recovery || !options.supersedeBinding, "RECONCILE_RECOVERY_MODE_CONFLICT");
@@ -123767,17 +124253,17 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (supersededBinding || recovery) {
       need8(Array.isArray(intent.nativeHooks) && intent.nativeHooks.length > 0, "RECONCILE_NATIVE_INVENTORY_REQUIRED");
       const proof = options.releaseProof;
-      need8(!!proof && isAbsolute46(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
+      need8(!!proof && isAbsolute47(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
     }
     const currentConfig = snapshot(intent.configPath, true);
     const policy = parseManagedSkillPolicy(policyCurrent.text), binding = policy.bridge;
-    const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join78(home, ".codex"), hooksPath = join78(physicalRoot, "hooks.json");
-    need8(resolve43(intent.configPath) === resolve43(join78(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
+    const alias = binding.rootAliases?.find((item) => item.agent === "codex"), physicalRoot = alias?.target ?? join79(home, ".codex"), hooksPath = join79(physicalRoot, "hooks.json");
+    need8(resolve44(intent.configPath) === resolve44(join79(physicalRoot, "config.toml")), "RECONCILE_CONFIG_PATH_CHANGED");
     const nativeConfigPath = intent.nativeConfigPath ?? intent.configPath;
-    need8([join78(home, ".codex/config.toml"), join78(physicalRoot, "config.toml")].includes(nativeConfigPath), "RECONCILE_NATIVE_CONFIG_PATH_CHANGED");
-    const codexHome = nativeConfigPath !== intent.configPath ? undefined : dirname51(nativeConfigPath);
+    need8([join79(home, ".codex/config.toml"), join79(physicalRoot, "config.toml")].includes(nativeConfigPath), "RECONCILE_NATIVE_CONFIG_PATH_CHANGED");
+    const codexHome = nativeConfigPath !== intent.configPath ? undefined : dirname52(nativeConfigPath);
     const hooksCurrent = snapshot(hooksPath);
-    const additions = additionsRecovery ? reviewNativeHookAdditions({ path: additionsRecovery.path, intent: intentFile, policy: policyCurrent, configBefore, configCurrent: currentConfig, hooksBefore, hooksCurrent, nativeHooksPath: join78(dirname51(nativeConfigPath), "hooks.json"), journalHooks: intent.hooks, recordedNativeHooks: intent.nativeHooks }) : undefined;
+    const additions = additionsRecovery ? reviewNativeHookAdditions({ path: additionsRecovery.path, intent: intentFile, policy: policyCurrent, configBefore, configCurrent: currentConfig, hooksBefore, hooksCurrent, nativeHooksPath: join79(dirname52(nativeConfigPath), "hooks.json"), journalHooks: intent.hooks, recordedNativeHooks: intent.nativeHooks }) : undefined;
     const managedHooks = [...intent.hooks, ...additions?.hooks ?? []];
     const managedKeys = managedHooks.map((h) => h.key);
     const witnessSame = codexTrustReconcileWitness(configBefore.text, managedKeys) === codexTrustReconcileWitness(currentConfig.text, managedKeys);
@@ -123841,7 +124327,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
         need8(isDeepStrictEqual22(actual, expected), "RECONCILE_UNRELATED_HOOK_CHANGED");
     }
     for (const wanted of intent.hooks) {
-      const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join78(home, ".codex/hooks.json"), hooksPath));
+      const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join79(home, ".codex/hooks.json"), hooksPath));
       need8(matches2.length === 1, "RECONCILE_NATIVE_IDENTITY_CHANGED");
       const h = matches2[0];
       const trusted = h.trustStatus === "trusted";
@@ -123890,7 +124376,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const receipt = { version: 1, status: preview2 ? "recovery-review-required" : supersededBinding ? "superseded" : "reconciled", reconciled: !preview2, supersededBinding, automaticRollback: false, journal, planDigest: intent.planDigest, nativeVersion: rpc.version, nativeStateVerified: !nativeTrustPending, nativeTrustPending, bindingRefreshRequired: !!configDiscoveryRecovery, nativeExecutionVerified: false, configSha256: currentConfig.sha256, hooksSha256: hooksCurrent.sha256, policySha256: policyBefore.sha256, policyBeforeSha256: policyBefore.sha256, policyCurrentSha256: policyCurrent.sha256, previousSkillsCli: intent.skillsCli, skillsCli: skillsCli.receipt, releaseProof: options.releaseProof, nativeInventoryScope: recordedNativeHooks ? "complete" : "declared-managed-hooks-only", unrelatedNativeHooksPreserved: !!recordedNativeHooks, unrelatedSettingsAndCommentsPreserved: true, ...recoveryPlan ? { recoveryPlan, recoveryPlanDigest } : {}, ...codexAdmissionReceipt(rpc.admission) };
     if (preview2)
       return receipt;
-    save(join78(journal, "receipt.json"), json2(receipt));
+    save(join79(journal, "receipt.json"), json2(receipt));
     return receipt;
   } catch (error61) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_RECONCILE_REFUSED";
@@ -123900,21 +124386,21 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
   }
 }
 async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRpc) {
-  const home = resolve43(options.home ?? homedir14());
-  return withCodexCorpusWriteAsync([join78(home, ".codex")], (_assertCurrent, admission) => enrollCodexNativeHooksUnlocked(options, connect, admission), options);
+  const home = resolve44(options.home ?? homedir14());
+  return withCodexCorpusWriteAsync([join79(home, ".codex")], (_assertCurrent, admission) => enrollCodexNativeHooksUnlocked(options, connect, admission), options);
 }
 async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
   let rpc, journal;
   try {
-    const home = resolve43(options.home ?? homedir14()), dataDir3 = resolve43(options.dataDir ?? getDataDirReadOnly());
+    const home = resolve44(options.home ?? homedir14()), dataDir3 = resolve44(options.dataDir ?? getDataDirReadOnly());
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
-    const policyFile = snapshot(join78(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
+    const policyFile = snapshot(join79(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
     const binding = policy.bridge, alias = binding.rootAliases?.find((item) => item.agent === "codex");
     const skillsCli = bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
-    const physicalRoot = alias?.target ?? join78(home, ".codex"), hooksPath = join78(physicalRoot, "hooks.json"), configPath = join78(physicalRoot, "config.toml");
-    need8(options.codexHome === undefined || isAbsolute46(options.codexHome) && [join78(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
+    const physicalRoot = alias?.target ?? join79(home, ".codex"), hooksPath = join79(physicalRoot, "hooks.json"), configPath = join79(physicalRoot, "config.toml");
+    need8(options.codexHome === undefined || isAbsolute47(options.codexHome) && [join79(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
     const codexHome = options.codexHome === undefined ? undefined : physicalRoot;
-    const nativeConfigPath = join78(codexHome ?? join78(home, ".codex"), "config.toml");
+    const nativeConfigPath = join79(codexHome ?? join79(home, ".codex"), "config.toml");
     const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure3(configFile.text);
     const declarations = JSON.parse(hooksFile.text).hooks, expected = [];
     for (const [event, [nativeEvent, label]] of Object.entries(eventNames)) {
@@ -123923,25 +124409,25 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
       need8(Array.isArray(groups), "DECLARATION_CHANGED");
       const matches2 = groups.flatMap((group, gi) => (group.hooks ?? []).flatMap((entry, hi) => entry.command === command ? [{ group, entry, gi, hi }] : []));
       need8(matches2.length === 1 && isDeepStrictEqual22(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
-      expected.push({ event: nativeEvent, key: `${join78(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
+      expected.push({ event: nativeEvent, key: `${join79(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
     }
     codexTrustTextWitness(configFile.text, expected.map((h) => h.key));
     rpc = await connect({ command: options.codexCommand ?? "codex", home, codexHome });
     need8(SUPPORTED_CODEX_HOOK_VERSIONS.includes(rpc.version), "NATIVE_UNSUPPORTED_VERSION");
     const list2 = async () => {
       const response = await rpc.request("hooks/list", { cwds: [home] });
-      const nativeRoots = [...new Set([physicalRoot, join78(home, ".codex")])];
-      const coexistenceWarnings = nativeRoots.flatMap((hooksRoot) => nativeRoots.map((configRoot) => `loading hooks from both ${join78(hooksRoot, "hooks.json")} and ${join78(configRoot, "config.toml")}; prefer a single representation for this layer`));
+      const nativeRoots = [...new Set([physicalRoot, join79(home, ".codex")])];
+      const coexistenceWarnings = nativeRoots.flatMap((hooksRoot) => nativeRoots.map((configRoot) => `loading hooks from both ${join79(hooksRoot, "hooks.json")} and ${join79(configRoot, "config.toml")}; prefer a single representation for this layer`));
       const entry = response?.data?.[0];
       need8(Array.isArray(response?.data) && response.data.length === 1 && entry.cwd === home && Array.isArray(entry.hooks) && entry.hooks.length <= 1e4 && Array.isArray(entry.errors) && entry.errors.length === 0 && Array.isArray(entry.warnings) && entry.warnings.length <= 1 && entry.warnings.every((warning) => typeof warning === "string" && coexistenceWarnings.includes(warning)), "NATIVE_DISCOVERY_REFUSED");
       return response.data[0].hooks;
     };
     const admit = (hooks) => expected.map((wanted) => {
-      const canonicalKey = wanted.key.replace(join78(home, ".codex/hooks.json"), hooksPath);
+      const canonicalKey = wanted.key.replace(join79(home, ".codex/hooks.json"), hooksPath);
       const matches2 = hooks.filter((h2) => h2.key === wanted.key || h2.key === canonicalKey);
       need8(matches2.length === 1, "AMBIGUOUS_IDENTITY");
       const h = matches2[0];
-      need8(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join78(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
+      need8(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join79(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
       need8(hooks.filter((other) => other.command === wanted.command).length === 1, "AMBIGUOUS_IDENTITY");
       need8(["trusted", "untrusted", "modified"].includes(h.trustStatus), "UNKNOWN_TRUST_STATUS");
       return { key: h.key, event: wanted.event, command: wanted.command, handlerType: h.handlerType, timeoutSec: h.timeoutSec, sourcePath: h.sourcePath, currentHash: h.currentHash, enabled: h.enabled, trustStatus: h.trustStatus };
@@ -123967,27 +124453,27 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     const baseReceipt = { planDigest, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, nativeConfigPath, ownedNativeProcessId: rpc.processId, agent: "codex", applied: false, planned, nativeEligible: planned.length === 0, bindingRefreshRequired: false, transport: "owned-stdio-process", existingSessionsReloaded: false, nativeExecutionVerified: false, ...codexAdmissionReceipt(admission) };
     if (options.apply)
       need8(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
-    const parent = join78(dataDir3, "native-hook-trust");
-    const st = lstatSync50(parent, { throwIfNoEntry: false });
+    const parent = join79(dataDir3, "native-hook-trust");
+    const st = lstatSync51(parent, { throwIfNoEntry: false });
     if (st) {
       need8(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
-      const priorJournals = readdirSync28(parent);
+      const priorJournals = readdirSync29(parent);
       need8(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
         need8(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
-        need8(lstatSync50(join78(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
+        need8(lstatSync51(join79(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
       }
     }
     if (!options.apply || !planned.length)
       return baseReceipt;
     if (!st)
-      mkdirSync32(parent, { mode: 448 });
-    journal = join78(parent, randomUUID16());
-    mkdirSync32(journal, { mode: 448 });
-    save(join78(journal, "config.before.toml"), configFile.bytes);
-    save(join78(journal, "hooks.before.json"), hooksFile.bytes);
-    save(join78(journal, "policy.before.json"), policyFile.bytes);
-    save(join78(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook), ...codexAdmissionReceipt(admission) }));
+      mkdirSync33(parent, { mode: 448 });
+    journal = join79(parent, randomUUID17());
+    mkdirSync33(journal, { mode: 448 });
+    save(join79(journal, "config.before.toml"), configFile.bytes);
+    save(join79(journal, "hooks.before.json"), hooksFile.bytes);
+    save(join79(journal, "policy.before.json"), policyFile.bytes);
+    save(join79(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook), ...codexAdmissionReceipt(admission) }));
     need8(isDeepStrictEqual22(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
@@ -124003,7 +124489,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     for (const h of planned)
       expectedConfig.hooks.state[h.key] = { ...expectedConfig.hooks.state[h.key], enabled: true, trusted_hash: h.currentHash };
     need8(isDeepStrictEqual22(structure3(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys4) === preservationText, "PRESERVATION_FAILED");
-    const savedConfig = snapshot(join78(journal, "config.before.toml"), true);
+    const savedConfig = snapshot(join79(journal, "config.before.toml"), true);
     need8(savedConfig.sha256 === configFile.sha256, "JOURNAL_CHANGED");
     const discoveryTransition = binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, savedConfig, after2, planned) : undefined;
     unchanged2(policyFile);
@@ -124019,13 +124505,13 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     skillsCli.recheck();
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: discoveryTransition });
     const receipt = { ...baseReceipt, applied: true, nativeEligible: true, bindingRefreshRequired: !!discoveryTransition, ...discoveryTransition ? { discoveryTransition } : {}, nativeConfigVersion: result2.version, journal, beforeSha256: configFile.sha256, afterSha256: after2.sha256, unrelatedSettingsAndCommentsPreserved: true };
-    save(join78(journal, "receipt.json"), json2(receipt));
+    save(join79(journal, "receipt.json"), json2(receipt));
     return receipt;
   } catch (error61) {
     const message = error61 instanceof Error && error61.message.startsWith("CODEX_HOOK_TRUST_") ? error61.message : "CODEX_HOOK_TRUST_REFUSED: verify managed bridge installation and native Codex support";
     if (journal) {
       try {
-        save(join78(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true, ...codexAdmissionReceipt(admission) }));
+        save(join79(journal, "stopped.json"), json2({ error: message.split(":")[0], automaticRollback: false, reconcileBeforeRetry: true, ...codexAdmissionReceipt(admission) }));
       } catch {}
     }
     throw new Error(message);
@@ -124034,7 +124520,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
   }
 }
 var json2 = (value) => JSON.stringify(value, null, 2) + `
-`, structure3 = (text5) => JSON.parse(JSON.stringify(Bun.TOML.parse(text5))), eventNames, makePlanDigest = (value) => createHash49("sha256").update(json2(value)).digest("hex"), safeNativeHook = (hook) => ({ key: hook.key, eventName: hook.eventName, handlerType: hook.handlerType, command: hook.command, matcher: hook.matcher, timeoutSec: hook.timeoutSec, async: hook.async, statusMessage: hook.statusMessage, additionalContextLimit: hook.additionalContextLimit, sourcePath: hook.sourcePath, source: hook.source, pluginId: hook.pluginId, isManaged: hook.isManaged, currentHash: hook.currentHash, enabled: hook.enabled, trustStatus: hook.trustStatus }), withoutCodexCommand = (value) => {
+`, structure3 = (text5) => JSON.parse(JSON.stringify(Bun.TOML.parse(text5))), eventNames, makePlanDigest = (value) => createHash50("sha256").update(json2(value)).digest("hex"), safeNativeHook = (hook) => ({ key: hook.key, eventName: hook.eventName, handlerType: hook.handlerType, command: hook.command, matcher: hook.matcher, timeoutSec: hook.timeoutSec, async: hook.async, statusMessage: hook.statusMessage, additionalContextLimit: hook.additionalContextLimit, sourcePath: hook.sourcePath, source: hook.source, pluginId: hook.pluginId, isManaged: hook.isManaged, currentHash: hook.currentHash, enabled: hook.enabled, trustStatus: hook.trustStatus }), withoutCodexCommand = (value) => {
   const copy = structuredClone(value);
   if (copy?.bridge?.commands && Object.hasOwn(copy.bridge.commands, "codex"))
     copy.bridge.commands.codex = "<reviewed-codex-binding>";
@@ -124058,9 +124544,9 @@ var init_agent_codex_trust = __esm(() => {
 });
 
 // src/lib/codex-native-trust.ts
-import { createHash as createHash50 } from "crypto";
-import { readFileSync as readFileSync47 } from "fs";
-import { join as join79, resolve as resolve44 } from "path";
+import { createHash as createHash51 } from "crypto";
+import { readFileSync as readFileSync48 } from "fs";
+import { join as join80, resolve as resolve45 } from "path";
 function refuse7(detail) {
   throw new Error(`NATIVE_SKILL_POLICY_TRUST_REFUSED: ${detail}`);
 }
@@ -124079,15 +124565,15 @@ function planCodexNativeTrust(options) {
     refuse7("digests must be unique");
   if (typeof expectedPolicySha256 !== "string" || !HEX_DIGEST2.test(expectedPolicySha256))
     refuse7("--expected-policy-sha256 must be lowercase SHA-256 hex");
-  const dataDir3 = resolve44(options.dataDir ?? getDataDirReadOnly()), policyPath = join79(dataDir3, "agent-policy.json");
+  const dataDir3 = resolve45(options.dataDir ?? getDataDirReadOnly()), policyPath = join80(dataDir3, "agent-policy.json");
   assertOperatorTrustRoot(dataDir3);
-  const snapshot2 = readManagedSkillPolicySnapshot(dataDir3);
-  if (!snapshot2)
+  const snapshot3 = readManagedSkillPolicySnapshot(dataDir3);
+  if (!snapshot3)
     refuse7("no managed policy; run skills hook install first");
-  const policySha256Before = sha7(snapshot2.text);
+  const policySha256Before = sha7(snapshot3.text);
   if (policySha256Before !== expectedPolicySha256)
     refuse7("the managed policy bytes differ from --expected-policy-sha256; read the current file and pass its SHA-256");
-  const policy = snapshot2.value;
+  const policy = snapshot3.value;
   if (!policy.bridge || typeof policy.bridge !== "object" || Array.isArray(policy.bridge))
     refuse7("the managed policy has no bridge binding; run skills hook install first");
   const current = parseCodexNativePolicyTrust(policy.bridge.codexNativePolicy);
@@ -124096,7 +124582,7 @@ function planCodexNativeTrust(options) {
   const next = { ...policy, bridge: { ...policy.bridge, codexNativePolicy: { executableDigests } } };
   assertAgentPolicyCollections(next);
   const after2 = serializeManagedSkillPolicy(next);
-  const plan = { dataDir: dataDir3, profileId: typeof policy.profileId === "string" ? policy.profileId : "default", changes: after2 === snapshot2.text ? [] : [{ path: policyPath, before: snapshot2.text, after: after2 }], nativeSkills: [], observedPolicy: { path: policyPath, before: snapshot2.text } };
+  const plan = { dataDir: dataDir3, profileId: typeof policy.profileId === "string" ? policy.profileId : "default", changes: after2 === snapshot3.text ? [] : [{ path: policyPath, before: snapshot3.text, after: after2 }], nativeSkills: [], observedPolicy: { path: policyPath, before: snapshot3.text } };
   return { schema: CODEX_NATIVE_TRUST_PLAN_SCHEMA, dataDir: dataDir3, policyPath, platform: platform2, digestsBefore: [...current.executableDigests[platform2] ?? []], digestsAfter: [...digests], policySha256Before, policySha256After: sha7(after2), plan };
 }
 function previewCodexNativeTrust(plan) {
@@ -124117,7 +124603,7 @@ function applyCodexNativeTrust(plan, expectedPolicySha256) {
     const backupPath = result2.backups[0];
     if (result2.backups.length !== 1 || typeof backupPath !== "string")
       throw new Error("NATIVE_SKILL_POLICY_TRUST_WRITE_UNVERIFIED: the pre-change backup was not recorded");
-    const backupSha256 = sha7(readFileSync47(backupPath));
+    const backupSha256 = sha7(readFileSync48(backupPath));
     if (backupSha256 !== plan.policySha256Before)
       throw new Error(`NATIVE_SKILL_POLICY_TRUST_WRITE_UNVERIFIED: the backup at ${backupPath} does not read back as the pre-change policy`);
     receipt.backup = { path: backupPath, sha256: backupSha256, verified: true };
@@ -124131,7 +124617,7 @@ function applyCodexNativeTrust(plan, expectedPolicySha256) {
   receipt.readback = { policySha256: sha7(readback.text), digests, verified: true };
   return receipt;
 }
-var CODEX_NATIVE_TRUST_PLAN_SCHEMA = "skills.codex-native-trust-plan/v1", CODEX_NATIVE_TRUST_RECEIPT_SCHEMA = "skills.codex-native-trust-receipt/v1", PLATFORM_KEY2, HEX_DIGEST2, MAX_DIGESTS = 16, sha7 = (data) => createHash50("sha256").update(data).digest("hex");
+var CODEX_NATIVE_TRUST_PLAN_SCHEMA = "skills.codex-native-trust-plan/v1", CODEX_NATIVE_TRUST_RECEIPT_SCHEMA = "skills.codex-native-trust-receipt/v1", PLATFORM_KEY2, HEX_DIGEST2, MAX_DIGESTS = 16, sha7 = (data) => createHash51("sha256").update(data).digest("hex");
 var init_codex_native_trust = __esm(() => {
   init_config();
   init_managed_policy();
@@ -124143,9 +124629,9 @@ var init_codex_native_trust = __esm(() => {
 });
 
 // src/lib/claude-prospective-review.ts
-import { createHash as createHash51 } from "crypto";
-import { lstatSync as lstatSync51, readFileSync as readFileSync48, readdirSync as readdirSync29, realpathSync as realpathSync24 } from "fs";
-import { basename as basename26, dirname as dirname52, isAbsolute as isAbsolute47, join as join80, relative as relative16, resolve as resolve45, sep as sep23 } from "path";
+import { createHash as createHash52 } from "crypto";
+import { lstatSync as lstatSync52, readFileSync as readFileSync49, readdirSync as readdirSync30, realpathSync as realpathSync24 } from "fs";
+import { basename as basename26, dirname as dirname53, isAbsolute as isAbsolute48, join as join81, relative as relative17, resolve as resolve46, sep as sep24 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual23 } from "util";
 function hashClaudeDiscoveryBinding(binding) {
   return sha8(JSON.stringify(binding));
@@ -124196,7 +124682,7 @@ function keys4(value, expected, name) {
     refuse8(`${name} has an unsupported shape`);
 }
 function abs(path2, name) {
-  if (typeof path2 !== "string" || !path2 || path2.length > 4096 || /[\x00-\x1f\x7f]/.test(path2) || !isAbsolute47(path2) || resolve45(path2) !== path2)
+  if (typeof path2 !== "string" || !path2 || path2.length > 4096 || /[\x00-\x1f\x7f]/.test(path2) || !isAbsolute48(path2) || resolve46(path2) !== path2)
     refuse8(`${name} must be a normalized absolute path`);
 }
 function validUtcTimestamp(value) {
@@ -124204,27 +124690,27 @@ function validUtcTimestamp(value) {
 }
 function safeFile(path2, name) {
   abs(path2, name);
-  for (let at2 = dirname52(path2);; at2 = dirname52(at2)) {
-    const stat4 = lstatSync51(at2, { throwIfNoEntry: false });
+  for (let at2 = dirname53(path2);; at2 = dirname53(at2)) {
+    const stat4 = lstatSync52(at2, { throwIfNoEntry: false });
     if (!stat4?.isDirectory() || stat4.isSymbolicLink())
       refuse8(`${name} traverses a symlink or non-directory`);
-    if (at2 === dirname52(at2))
+    if (at2 === dirname53(at2))
       break;
   }
-  const stat3 = lstatSync51(path2, { throwIfNoEntry: false });
+  const stat3 = lstatSync52(path2, { throwIfNoEntry: false });
   if (!stat3?.isFile() || stat3.isSymbolicLink() || stat3.size > MAX_CANDIDATE_BYTES)
     refuse8(`${name} is not a bounded regular file`);
-  return readFileSync48(path2);
+  return readFileSync49(path2);
 }
 function canonicalDir(path2, name) {
   abs(path2, name);
-  if (realpathSync24(path2) !== path2 || !lstatSync51(path2).isDirectory())
+  if (realpathSync24(path2) !== path2 || !lstatSync52(path2).isDirectory())
     refuse8(`${name} is not a canonical directory`);
-  for (let at2 = path2;; at2 = dirname52(at2)) {
-    const stat3 = lstatSync51(at2);
+  for (let at2 = path2;; at2 = dirname53(at2)) {
+    const stat3 = lstatSync52(at2);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       refuse8(`${name} traverses a symlink`);
-    if (at2 === dirname52(at2))
+    if (at2 === dirname53(at2))
       break;
   }
 }
@@ -124233,17 +124719,17 @@ function captureClaudeProspectiveCandidateClosure(root2) {
   const entries = [];
   let bytes = 0;
   const walk2 = (directory3) => {
-    const beforeDirectory = lstatSync51(directory3);
-    const names = readdirSync29(directory3).sort();
+    const beforeDirectory = lstatSync52(directory3);
+    const names = readdirSync30(directory3).sort();
     if (new Set(names).size !== names.length)
       refuse8("candidate contains ambiguous directory entries");
     for (const name of names) {
       if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\") || /[\x00-\x1f\x7f]/.test(name))
         refuse8("candidate contains an unsupported path member");
-      const path2 = join80(directory3, name), rel = relative16(root2, path2).split(sep23).join("/");
+      const path2 = join81(directory3, name), rel = relative17(root2, path2).split(sep24).join("/");
       if (entries.length >= MAX_CANDIDATE_FILES)
         refuse8("candidate closure exceeds its member limit");
-      const stat3 = lstatSync51(path2);
+      const stat3 = lstatSync52(path2);
       if (stat3.isSymbolicLink())
         refuse8("candidate closure contains a symlink");
       if (stat3.isDirectory()) {
@@ -124253,14 +124739,14 @@ function captureClaudeProspectiveCandidateClosure(root2) {
         bytes += stat3.size;
         if (bytes > MAX_CANDIDATE_BYTES)
           refuse8("candidate closure exceeds its byte limit");
-        const content = safeFile(path2, "candidate member"), after2 = lstatSync51(path2);
+        const content = safeFile(path2, "candidate member"), after2 = lstatSync52(path2);
         if (!after2.isFile() || after2.dev !== stat3.dev || after2.ino !== stat3.ino || after2.size !== stat3.size || after2.mtimeMs !== stat3.mtimeMs || after2.ctimeMs !== stat3.ctimeMs)
           refuse8("candidate member changed while being read");
         entries.push([rel, "file", sha8(content)]);
       } else
         refuse8("candidate closure contains a special file");
     }
-    const afterDirectory = lstatSync51(directory3);
+    const afterDirectory = lstatSync52(directory3);
     if (!afterDirectory.isDirectory() || afterDirectory.dev !== beforeDirectory.dev || afterDirectory.ino !== beforeDirectory.ino || afterDirectory.mtimeMs !== beforeDirectory.mtimeMs || afterDirectory.ctimeMs !== beforeDirectory.ctimeMs)
       refuse8("candidate directory changed while being read");
   };
@@ -124271,9 +124757,9 @@ function captureClaudeProspectiveCandidateClosure(root2) {
 function captureClaudeInstallerCandidate(root2, policyPath) {
   const closureSha256 = captureClaudeProspectiveCandidateClosure(root2);
   const dataDir3 = getDataDirReadOnly();
-  if (policyPath !== join80(dataDir3, "agent-policy.json"))
+  if (policyPath !== join81(dataDir3, "agent-policy.json"))
     refuse8("Skills policy path differs from the package-owned resolver");
-  const catalogPath = join80(root2, ".claude-plugin/marketplace.json");
+  const catalogPath = join81(root2, ".claude-plugin/marketplace.json");
   const catalog = jsonFile(catalogPath, "candidate catalog");
   if (!catalog || !Array.isArray(catalog.plugins))
     refuse8("candidate catalog is invalid");
@@ -124284,13 +124770,13 @@ function captureClaudeInstallerCandidate(root2, policyPath) {
     if (names.has(row2.name))
       refuse8("candidate catalog repeats a plugin name");
     names.add(row2.name);
-    if (typeof row2.source !== "string" || isAbsolute47(row2.source) || /[\\\x00-\x1f\x7f]/.test(row2.source))
+    if (typeof row2.source !== "string" || isAbsolute48(row2.source) || /[\\\x00-\x1f\x7f]/.test(row2.source))
       refuse8("candidate catalog plugin source is invalid");
-    const pluginRoot = resolve45(root2, row2.source);
-    const relativeRoot = relative16(root2, pluginRoot);
-    if (!relativeRoot || relativeRoot === "." || relativeRoot === ".." || relativeRoot.startsWith(`..${sep23}`) || isAbsolute47(relativeRoot))
+    const pluginRoot = resolve46(root2, row2.source);
+    const relativeRoot = relative17(root2, pluginRoot);
+    if (!relativeRoot || relativeRoot === "." || relativeRoot === ".." || relativeRoot.startsWith(`..${sep24}`) || isAbsolute48(relativeRoot))
       refuse8("candidate plugin source escapes the candidate root");
-    const path2 = join80(pluginRoot, ".claude-plugin/plugin.json");
+    const path2 = join81(pluginRoot, ".claude-plugin/plugin.json");
     return { plugin: row2.name, ...captureClaudePluginManifestFile(path2) };
   });
   const policy = readManagedSkillPolicySnapshot(dataDir3);
@@ -124307,7 +124793,7 @@ function captureClaudeInstallerCandidate(root2, policyPath) {
 }
 function readWitness(path2, expected, name) {
   abs(path2, `${name} path`);
-  const stat3 = lstatSync51(path2, { throwIfNoEntry: false });
+  const stat3 = lstatSync52(path2, { throwIfNoEntry: false });
   if (expected === null) {
     if (stat3)
       refuse8(`${name} was absent at review but is now present`);
@@ -124359,7 +124845,7 @@ function unreviewedProjectSettingsRefusal(path2, expected, name) {
   return null;
 }
 function jsonFile(path2, name) {
-  const stat3 = lstatSync51(path2, { throwIfNoEntry: false });
+  const stat3 = lstatSync52(path2, { throwIfNoEntry: false });
   if (!stat3)
     return null;
   let value;
@@ -124389,9 +124875,9 @@ function assertNoUnprojectedSkillPayload(root2, catalogPath, marketplace, plugin
   if (entries[0].skills !== undefined || entries[0].commands !== undefined)
     refuse8("candidate marketplace entry declares native skill or command payloads");
   const walk2 = (directory3) => {
-    for (const name of readdirSync29(directory3).sort()) {
-      const path2 = join80(directory3, name), rel = relative16(root2, path2).split(sep23).join("/");
-      const stat3 = lstatSync51(path2);
+    for (const name of readdirSync30(directory3).sort()) {
+      const path2 = join81(directory3, name), rel = relative17(root2, path2).split(sep24).join("/");
+      const stat3 = lstatSync52(path2);
       if (stat3.isDirectory())
         walk2(path2);
       else if (stat3.isFile()) {
@@ -124436,10 +124922,10 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   abs(request2.skills.dataDir, "Skills data directory");
   if (!SHA2562.test(request2.skills.policySha256) || !SHA2562.test(request2.skills.discoverySha256))
     refuse8("invalid Skills policy or discovery SHA-256");
-  const snapshot2 = readManagedSkillPolicySnapshot(request2.skills.dataDir);
-  if (!snapshot2 || sha8(snapshot2.text) !== request2.skills.policySha256)
+  const snapshot3 = readManagedSkillPolicySnapshot(request2.skills.dataDir);
+  if (!snapshot3 || sha8(snapshot3.text) !== request2.skills.policySha256)
     refuse8("Skills policy preimage changed or is absent");
-  const aliases = snapshot2.value.bridge?.rootAliases ?? [];
+  const aliases = snapshot3.value.bridge?.rootAliases ?? [];
   if (!Array.isArray(aliases))
     refuse8("Skills policy root aliases are invalid");
   try {
@@ -124448,16 +124934,16 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     refuse8("Skills policy root alias changed or is invalid");
   }
   const canonical9 = (path2) => canonicalAgentPath(path2, aliases);
-  const configRoot = canonical9(join80(request2.native.home, ".claude"));
+  const configRoot = canonical9(join81(request2.native.home, ".claude"));
   canonicalDir(configRoot, "Claude config root");
   if (request2.native.configRoot !== configRoot)
     refuse8("Claude config root differs from the current resolver and reviewed root alias");
-  const pluginRoot = join80(configRoot, "plugins");
+  const pluginRoot = join81(configRoot, "plugins");
   if (process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR)
     refuse8("CLAUDE_CODE_PLUGIN_CACHE_DIR overrides are unsupported by this prospective schema; bind and review the actual cache root first");
   if (request2.native.pluginRoot !== pluginRoot)
     refuse8("Claude plugin root differs from the supported standard plugins directory; Cowork and custom cache roots require a separately bound schema");
-  const pluginRootStat = lstatSync51(pluginRoot, { throwIfNoEntry: false });
+  const pluginRootStat = lstatSync52(pluginRoot, { throwIfNoEntry: false });
   if (pluginRootStat && (!pluginRootStat.isDirectory() || pluginRootStat.isSymbolicLink()))
     refuse8("Claude plugin root is not a regular directory");
   keys4(request2.candidate, ["marketplace", "root", "catalogPath", "catalogSha256", "closureSha256", "plugins", ...hasOwn2(request2.candidate, "releaseManifest") ? ["releaseManifest"] : [], ...hasOwn2(request2.candidate, "functionHooksEnv") ? ["functionHooksEnv"] : [], ...hasOwn2(request2.candidate, "settingsMarketplaceSource") ? ["settingsMarketplaceSource"] : []], "candidate");
@@ -124475,9 +124961,9 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   if (hasOwn2(candidate2, "settingsMarketplaceSource") && (candidate2.settingsMarketplaceSource !== "directory" || request2.scope.kind !== "user" || !measuredSettingsWriter))
     refuse8("settings marketplace source operation requires directory source and a measured Claude user-scope writer");
   abs(candidate2.catalogPath, "catalog path");
-  if (!candidate2.catalogPath.startsWith(candidate2.root + sep23))
+  if (!candidate2.catalogPath.startsWith(candidate2.root + sep24))
     refuse8("catalog must be inside the frozen candidate root");
-  if (candidate2.catalogPath !== join80(candidate2.root, ".claude-plugin", "marketplace.json"))
+  if (candidate2.catalogPath !== join81(candidate2.root, ".claude-plugin", "marketplace.json"))
     refuse8("marketplace catalog must be at the frozen root's .claude-plugin/marketplace.json path");
   if (!SHA2562.test(candidate2.catalogSha256) || !SHA2562.test(candidate2.closureSha256))
     refuse8("candidate digests must be lowercase SHA-256");
@@ -124519,11 +125005,11 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     if (Buffer.byteLength(canonicalJson3(selected.optionsPatch), "utf8") > 16 * 1024)
       refuse8("selected plugin optionsPatch exceeds its byte bound");
     abs(selected.manifestPath, "manifest path");
-    if (!selected.manifestPath.startsWith(candidate2.root + sep23) || basename26(dirname52(selected.manifestPath)) !== ".claude-plugin" || selected.manifestPath !== join80(dirname52(dirname52(selected.manifestPath)), ".claude-plugin", "plugin.json"))
+    if (!selected.manifestPath.startsWith(candidate2.root + sep24) || basename26(dirname53(selected.manifestPath)) !== ".claude-plugin" || selected.manifestPath !== join81(dirname53(dirname53(selected.manifestPath)), ".claude-plugin", "plugin.json"))
       refuse8("plugin manifest must be under a plugin root inside the frozen marketplace closure");
-    const pluginRoot2 = dirname52(dirname52(selected.manifestPath));
-    const relativePluginRoot = relative16(candidate2.root, pluginRoot2);
-    if (!relativePluginRoot || relativePluginRoot === "." || relativePluginRoot === ".." || relativePluginRoot.startsWith(`..${sep23}`) || isAbsolute47(relativePluginRoot))
+    const pluginRoot2 = dirname53(dirname53(selected.manifestPath));
+    const relativePluginRoot = relative17(candidate2.root, pluginRoot2);
+    if (!relativePluginRoot || relativePluginRoot === "." || relativePluginRoot === ".." || relativePluginRoot.startsWith(`..${sep24}`) || isAbsolute48(relativePluginRoot))
       refuse8("plugin root must be a child of the frozen marketplace root");
     canonicalDir(pluginRoot2, "candidate plugin root");
     if (!SHA2562.test(selected.manifestSha256))
@@ -124555,9 +125041,9 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
       refuse8("selected plugins collide after native cache path sanitization");
     sanitizedCachePaths.add(sanitizedCachePath);
     const sourcePath = selectedEntry.source;
-    const sourceRelativePath = relative16(candidate2.root, pluginRoot2).split(sep23).join("/");
+    const sourceRelativePath = relative17(candidate2.root, pluginRoot2).split(sep24).join("/");
     const expectedSourcePath = sourceRelativePath === "." ? "./" : `./${sourceRelativePath}`;
-    if (typeof sourcePath !== "string" || isAbsolute47(sourcePath) || sourcePath !== expectedSourcePath || resolve45(dirname52(dirname52(candidate2.catalogPath)), sourcePath) !== pluginRoot2)
+    if (typeof sourcePath !== "string" || isAbsolute48(sourcePath) || sourcePath !== expectedSourcePath || resolve46(dirname53(dirname53(candidate2.catalogPath)), sourcePath) !== pluginRoot2)
       refuse8("marketplace source does not resolve to the frozen plugin closure; external source mapping is not supported by this schema");
     const entry = captureClaudeMarketplaceEntry(candidate2.catalogPath, candidate2.marketplace, selected.plugin);
     if (entry.sha256.length !== 64)
@@ -124577,12 +125063,12 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   for (const name of ["settings", "projectSettings", "projectSettingsLocal", "marketplaces", "installedPlugins"])
     keys4(request2.preimages[name], ["path", "sha256"], `${name} preimage`);
   const expectedPaths = {
-    settings: request2.scope.kind === "project" ? canonical9(join80(request2.scope.projectPath, ".claude/settings.json")) : canonical9(join80(request2.native.home, ".claude/settings.json")),
-    userSettings: canonical9(join80(request2.native.home, ".claude/settings.json")),
-    projectSettings: canonical9(join80(request2.scope.projectPath, ".claude/settings.json")),
-    projectSettingsLocal: canonical9(join80(request2.scope.projectPath, ".claude/settings.local.json")),
-    marketplaces: canonical9(join80(request2.native.home, ".claude/plugins/known_marketplaces.json")),
-    installedPlugins: canonical9(join80(request2.native.home, ".claude/plugins/installed_plugins.json"))
+    settings: request2.scope.kind === "project" ? canonical9(join81(request2.scope.projectPath, ".claude/settings.json")) : canonical9(join81(request2.native.home, ".claude/settings.json")),
+    userSettings: canonical9(join81(request2.native.home, ".claude/settings.json")),
+    projectSettings: canonical9(join81(request2.scope.projectPath, ".claude/settings.json")),
+    projectSettingsLocal: canonical9(join81(request2.scope.projectPath, ".claude/settings.local.json")),
+    marketplaces: canonical9(join81(request2.native.home, ".claude/plugins/known_marketplaces.json")),
+    installedPlugins: canonical9(join81(request2.native.home, ".claude/plugins/installed_plugins.json"))
   };
   for (const name of Object.keys(expectedPaths)) {
     const witness = request2.preimages[name];
@@ -124617,8 +125103,8 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   if (hashClaudeDiscoveryBinding(binding) !== request2.skills.discoverySha256)
     refuse8("Skills discovery preimage differs from its reviewed binding");
   assertProjectDiscovery("claude", [request2.scope.projectPath], request2.native.home, canonical9, binding);
-  const stored = snapshot2.value.bridge?.discovery?.claude;
-  if (!stored || !isDeepStrictEqual23(stored, binding) || snapshot2.value.bridge?.home !== request2.native.home)
+  const stored = snapshot3.value.bridge?.discovery?.claude;
+  if (!stored || !isDeepStrictEqual23(stored, binding) || snapshot3.value.bridge?.home !== request2.native.home)
     refuse8("Skills policy does not bind the reviewed current Claude discovery");
   assertExemptUnchanged();
   const delta = request2.delta;
@@ -124715,7 +125201,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     const manifestVersion = manifest.version;
     const sanitizeComponent = (value) => value.replace(/[^A-Za-z0-9_-]/g, "-");
     const sanitizedVersion = manifestVersion === "." || manifestVersion === ".." ? "-" : manifestVersion.replace(/[^A-Za-z0-9._-]/g, "-");
-    const expectedInstallPath = join80(pluginRoot, "cache", sanitizeComponent(candidate2.marketplace), sanitizeComponent(plugin), sanitizedVersion);
+    const expectedInstallPath = join81(pluginRoot, "cache", sanitizeComponent(candidate2.marketplace), sanitizeComponent(plugin), sanitizedVersion);
     if (expectedInstallPath.length > 4096)
       refuse8("candidate native cache path exceeds its bound");
     const targetRegistration = {
@@ -124854,7 +125340,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
       { name: "project-settings-local", path: expectedPaths.projectSettingsLocal, sha256: request2.preimages.projectSettingsLocal.sha256 },
       { name: "known-marketplaces", path: expectedPaths.marketplaces, sha256: request2.preimages.marketplaces.sha256 },
       { name: "installed-plugins", path: expectedPaths.installedPlugins, sha256: request2.preimages.installedPlugins.sha256 },
-      { name: "skills-policy", path: join80(request2.skills.dataDir, "agent-policy.json"), sha256: request2.skills.policySha256 }
+      { name: "skills-policy", path: join81(request2.skills.dataDir, "agent-policy.json"), sha256: request2.skills.policySha256 }
     ],
     ownedDelta: { settingsEnabledPlugins: selectedPluginIds, selectedPluginOptions: selectedOptionPaths, functionHooksEnv: candidate2.functionHooksEnv ?? null, knownMarketplace: candidate2.marketplace, installedPlugins: selectedPluginIds, unrelatedGraph: "preserved-by-complete-semantic-documents" },
     identityPrecondition: "Harnesses must resolve the installed Claude home/config/plugin roots and executable path/version/hash plus the installed Skills data directory through their package-owned consumers, then compare every value before trusting this receipt; this validator checks supplied paths and current bytes only and does not establish actual consumer identity",
@@ -124862,7 +125348,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     limitation: "validation-only; native installer atomicity and crash recovery are not established"
   };
 }
-var CLAUDE_PROSPECTIVE_REVIEW_SCHEMA = "skills.claude-plugin-prospective-review/v1", SHA2562, MAX_CANDIDATE_FILES = 16384, MAX_CANDIDATE_BYTES, sha8 = (data) => createHash51("sha256").update(data).digest("hex"), GENERATED_MARKETPLACE_TIME, GENERATED_FRESH_PLUGIN_INSTALLED_AT, GENERATED_PLUGIN_UPDATE_TIME, EXEMPT_PROJECT_SETTINGS, EXEMPT_PROJECT_PERMISSIONS;
+var CLAUDE_PROSPECTIVE_REVIEW_SCHEMA = "skills.claude-plugin-prospective-review/v1", SHA2562, MAX_CANDIDATE_FILES = 16384, MAX_CANDIDATE_BYTES, sha8 = (data) => createHash52("sha256").update(data).digest("hex"), GENERATED_MARKETPLACE_TIME, GENERATED_FRESH_PLUGIN_INSTALLED_AT, GENERATED_PLUGIN_UPDATE_TIME, EXEMPT_PROJECT_SETTINGS, EXEMPT_PROJECT_PERMISSIONS;
 var init_claude_prospective_review = __esm(() => {
   init_agent_discovery();
   init_agent_integration();
@@ -124896,7 +125382,7 @@ var init_claude_prospective_review = __esm(() => {
 
 // src/lib/codex-plugin-reconcile.ts
 import { realpathSync as realpathSync25 } from "fs";
-import { join as join81, resolve as resolve46 } from "path";
+import { join as join82, resolve as resolve47 } from "path";
 function boundedMessage(text5) {
   const line = text5.replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/g, " ").trim();
   return line.length > 800 ? `${line.slice(0, 797)}...` : line;
@@ -124930,20 +125416,20 @@ async function runCodexPluginReconcile(options) {
   const mode = options.apply ? "apply" : "preview";
   const base3 = emptyResult(mode);
   try {
-    const home = resolve46(options.home), projectDir = resolve46(options.projectDir), dataDir3 = options.dataDir ?? getDataDirReadOnly();
+    const home = resolve47(options.home), projectDir = resolve47(options.projectDir), dataDir3 = options.dataDir ?? getDataDirReadOnly();
     if (options.codexHome !== undefined) {
       const canonical9 = (path2) => {
         try {
           return realpathSync25(path2);
         } catch {
-          return resolve46(path2);
+          return resolve47(path2);
         }
       };
-      if (canonical9(options.codexHome) !== canonical9(join81(home, ".codex")))
+      if (canonical9(options.codexHome) !== canonical9(join82(home, ".codex")))
         throw new CodexPluginReconcileRefusal("CODEX_RECONCILE_CODEX_HOME_UNSUPPORTED", "CODEX_HOME names a Codex home other than the one the Skills binding reviews");
     }
     const capture2 = options.captureCatalog ?? captureCodexNativeSkillCatalog;
-    const remoteReceipts = captureCodexRemoteReceiptSnapshot(join81(home, ".codex/plugins/cache"));
+    const remoteReceipts = captureCodexRemoteReceiptSnapshot(join82(home, ".codex/plugins/cache"));
     const captured = await capture2({ command: options.codexCommand ?? "codex", home, ...options.codexHome === undefined ? {} : { codexHome: options.codexHome }, cwd: projectDir });
     const catalog = captured && typeof captured === "object" ? { ...captured, remoteReceipts } : captured;
     base3.codexVersion = typeof catalog?.version === "string" ? catalog.version : null;
@@ -124968,7 +125454,7 @@ async function runCodexPluginReconcile(options) {
     if (!options.apply)
       return { ...reported, outcome: "planned", changes };
     const applied = await applyCodexPluginReconcile(plan, { ...options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }, ...options.codexHome === undefined ? {} : { codexHome: options.codexHome }, ...options.connect ? { connect: options.connect } : {} });
-    return { ...reported, outcome: "applied", changes: applied.changed, ...applied.receipt ? { receipt: resolve46(applied.receipt) } : {}, backups: applied.backups };
+    return { ...reported, outcome: "applied", changes: applied.changed, ...applied.receipt ? { receipt: resolve47(applied.receipt) } : {}, backups: applied.backups };
   } catch (error61) {
     return { ...base3, ...classifyCodexReconcileError(error61) };
   }
@@ -125004,23 +125490,23 @@ var init_codex_plugin_reconcile = __esm(() => {
 });
 
 // src/lib/claude-installer-binding.ts
-import { createHash as createHash52 } from "crypto";
-import { join as join82 } from "path";
+import { createHash as createHash53 } from "crypto";
+import { join as join83 } from "path";
 function readPolicy(dataDir3) {
-  let snapshot2;
+  let snapshot3;
   try {
-    snapshot2 = readManagedSkillPolicySnapshot(dataDir3);
+    snapshot3 = readManagedSkillPolicySnapshot(dataDir3);
   } catch {
     return refuse9("POLICY_UNREADABLE");
   }
-  return snapshot2 ?? refuse9("POLICY_UNAVAILABLE");
+  return snapshot3 ?? refuse9("POLICY_UNAVAILABLE");
 }
 function verifyClaudeInstallerDiscoveryBinding(policyPath) {
   const dataDir3 = getDataDirReadOnly();
-  if (policyPath !== join82(dataDir3, "agent-policy.json"))
+  if (policyPath !== join83(dataDir3, "agent-policy.json"))
     refuse9("POLICY_PATH_MISMATCH");
-  const snapshot2 = readPolicy(dataDir3);
-  const bridge = snapshot2.value.bridge;
+  const snapshot3 = readPolicy(dataDir3);
+  const bridge = snapshot3.value.bridge;
   const binding = object14(bridge) && object14(bridge.discovery) ? bridge.discovery.claude : undefined;
   if (!object14(binding))
     return refuse9("BINDING_UNAVAILABLE");
@@ -125062,12 +125548,12 @@ function verifyClaudeInstallerDiscoveryBinding(policyPath) {
     ...directories.flatMap((row2) => row2.status === "drift" ? [{ kind: "directory", index: row2.index, path: row2.path, reason: row2.reason }] : []),
     ...accepted ? [] : [{ kind: "binding", reason: "DISCOVERY_REFUSED" }]
   ];
-  if (readPolicy(dataDir3).text !== snapshot2.text)
+  if (readPolicy(dataDir3).text !== snapshot3.text)
     refuse9("POLICY_CHANGED");
   return {
     schema: CLAUDE_DISCOVERY_BINDING_VERIFICATION_SCHEMA,
     ok: failures3.length === 0,
-    policySha256: createHash52("sha256").update(snapshot2.text).digest("hex"),
+    policySha256: createHash53("sha256").update(snapshot3.text).digest("hex"),
     discoverySha256: hashClaudeDiscoveryBinding(binding),
     agent: "claude",
     method: binding.method,
@@ -125096,8 +125582,8 @@ var init_claude_installer_binding = __esm(() => {
 });
 
 // src/cli/commands/claude-installer-capture.ts
-import { closeSync as closeSync33, constants as constants33, fstatSync as fstatSync32, lstatSync as lstatSync52, openSync as openSync33, readSync as readSync25 } from "fs";
-import { isAbsolute as isAbsolute48, resolve as resolve47 } from "path";
+import { closeSync as closeSync33, constants as constants33, fstatSync as fstatSync32, lstatSync as lstatSync53, openSync as openSync33, readSync as readSync25 } from "fs";
+import { isAbsolute as isAbsolute49, resolve as resolve48 } from "path";
 function need11(condition, code2) {
   if (!condition)
     throw new CaptureRefusal(code2);
@@ -125111,11 +125597,11 @@ function exactKeys5(value, expected, operation) {
   }
 }
 function canonicalPath2(value) {
-  need11(typeof value === "string" && isAbsolute48(value) && resolve47(value) === value && !/[\x00-\x1f\x7f]/.test(value), "INVALID_PATH: path fields must be normalized absolute paths without control characters");
+  need11(typeof value === "string" && isAbsolute49(value) && resolve48(value) === value && !/[\x00-\x1f\x7f]/.test(value), "INVALID_PATH: path fields must be normalized absolute paths without control characters");
 }
 function readRequest2(path2) {
   canonicalPath2(path2);
-  const before2 = lstatSync52(path2, { throwIfNoEntry: false });
+  const before2 = lstatSync53(path2, { throwIfNoEntry: false });
   if (!before2?.isFile() || before2.isSymbolicLink() || before2.size > MAX_REQUEST_BYTES)
     throw new CaptureRefusal("INVALID_REQUEST_FILE: --request must name a regular non-symlink JSON file no larger than 64 KiB");
   const fd = openSync33(path2, constants33.O_RDONLY | (constants33.O_NOFOLLOW ?? 0) | constants33.O_NONBLOCK);
@@ -125130,7 +125616,7 @@ function readRequest2(path2) {
         break;
       length += count;
     }
-    const after2 = fstatSync32(fd), current = lstatSync52(path2);
+    const after2 = fstatSync32(fd), current = lstatSync53(path2);
     need11(length <= MAX_REQUEST_BYTES && length === opened.size && after2.size === opened.size && after2.mtimeMs === opened.mtimeMs && after2.ctimeMs === opened.ctimeMs && current.dev === opened.dev && current.ino === opened.ino && current.mtimeMs === opened.mtimeMs && current.ctimeMs === opened.ctimeMs, "INVALID_REQUEST_FILE: --request must remain unchanged while read");
     try {
       return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
@@ -125292,10 +125778,10 @@ __export(exports_agent_integration, {
   MANAGED_HOOK_CONTEXT_MAX_SKILLS: () => MANAGED_HOOK_CONTEXT_MAX_SKILLS,
   MANAGED_HOOK_CONTEXT_MAX_CHARS: () => MANAGED_HOOK_CONTEXT_MAX_CHARS
 });
-import { existsSync as existsSync36, lstatSync as lstatSync53, readFileSync as readFileSync49, readSync as readSync26, writeFileSync as writeFileSync29 } from "fs";
-import { createHash as createHash53 } from "crypto";
+import { existsSync as existsSync37, lstatSync as lstatSync54, readFileSync as readFileSync50, readSync as readSync26, writeFileSync as writeFileSync30 } from "fs";
+import { createHash as createHash54 } from "crypto";
 import { homedir as homedir15 } from "os";
-import { basename as basename27, isAbsolute as isAbsolute49, resolve as resolve48 } from "path";
+import { basename as basename27, isAbsolute as isAbsolute50, resolve as resolve49 } from "path";
 function boundedEnvInteger(name, fallback, [min2, max2]) {
   const raw = process.env[name];
   if (raw === undefined || !/^[0-9]{1,6}$/.test(raw.trim()))
@@ -125479,9 +125965,9 @@ function registerAgentIntegration(parent) {
   });
   hook.command("native-catalog").requiredOption("--cwd <path>", "Absolute project directory observed by native Codex skills/list").requiredOption("--output <file>", "New private file for the projected native catalog").option("--codex-command <path>", "Installed Codex executable used by the native client", "codex").option("--json", "Output bounded capture metadata as JSON", false).description("Capture a reviewed Codex native skill catalog for exact hook enrollment").action(async (options) => {
     try {
-      if (!isAbsolute49(options.cwd) || !isAbsolute49(options.output))
+      if (!isAbsolute50(options.cwd) || !isAbsolute50(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_ABSOLUTE_PATH_REQUIRED");
-      if (existsSync36(options.output))
+      if (existsSync37(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
       let admission;
       const catalog = await captureCodexNativeSkillCatalog({
@@ -125497,14 +125983,14 @@ function registerAgentIntegration(parent) {
       const bytes = JSON.stringify(catalog, null, 2) + `
 `;
       try {
-        writeFileSync29(options.output, bytes, { flag: "wx", mode: 384 });
+        writeFileSync30(options.output, bytes, { flag: "wx", mode: 384 });
       } catch (error61) {
         if (error61 && typeof error61 === "object" && "code" in error61 && error61.code === "EEXIST")
           throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
         throw error61;
       }
-      const written = lstatSync53(options.output);
-      if (!written.isFile() || written.isSymbolicLink() || (written.mode & 63) !== 0 || readFileSync49(options.output, "utf8") !== bytes)
+      const written = lstatSync54(options.output);
+      if (!written.isFile() || written.isSymbolicLink() || (written.mode & 63) !== 0 || readFileSync50(options.output, "utf8") !== bytes)
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_READBACK_FAILED");
       const receipt = {
         version: catalog.version,
@@ -125512,7 +125998,7 @@ function registerAgentIntegration(parent) {
         skillCount: catalog.skills.length,
         output: options.output,
         bytes: Buffer.byteLength(bytes),
-        sha256: createHash53("sha256").update(bytes).digest("hex"),
+        sha256: createHash54("sha256").update(bytes).digest("hex"),
         ...codexAdmissionReceipt(admission)
       };
       await writeCliOutput(options.json ? JSON.stringify(receipt) : `Captured ${receipt.skillCount} native Codex skill(s) in ${receipt.output}.`);
@@ -125546,7 +126032,7 @@ function registerAgentIntegration(parent) {
       if (!options.reviewedHookSources)
         throw new Error("Codex V6 requires a bounded --reviewed-hook-sources JSON array");
       const { hashNativeJsonControls: hashNativeJsonControls2, readNativeSettingsWitnessFile: readNativeSettingsWitnessFile2 } = await Promise.resolve().then(() => (init_claude_settings_witness(), exports_claude_settings_witness));
-      const metadata2 = resolve48(options.reviewedHookSources);
+      const metadata2 = resolve49(options.reviewedHookSources);
       const text5 = readNativeSettingsWitnessFile2(metadata2, { remaining: 1048576 }, basename27(metadata2));
       hashNativeJsonControls2(`{"sources":${text5}}`);
       await writeCliOutput(JSON.stringify(captureCodexSettingsV6(options.path, JSON.parse(text5)), null, 2));
@@ -125581,14 +126067,14 @@ function registerAgentIntegration(parent) {
   });
   hook.command("review-claude-candidate").requiredOption("--request <file>", "Frozen skills.claude-plugin-prospective-review/v1 JSON request").option("--json", "Return the validation-only receipt as JSON", false).description("Validate a prospective Claude plugin candidate and current preimages without changing native state; Harnesses must compare native and Skills paths against installed package-owned resolvers before trusting the receipt").action(async (options) => {
     try {
-      if (!isAbsolute49(options.request))
+      if (!isAbsolute50(options.request))
         throw new Error("CLAUDE_CANDIDATE_REVIEW_REFUSED: --request must be an absolute path");
-      const stat3 = lstatSync53(options.request);
+      const stat3 = lstatSync54(options.request);
       if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > 1024 * 1024)
         throw new Error("CLAUDE_CANDIDATE_REVIEW_REFUSED: request must be a regular file no larger than 1 MiB");
-      const requestBytes = readFileSync49(options.request);
+      const requestBytes = readFileSync50(options.request);
       const request2 = JSON.parse(requestBytes.toString("utf8"));
-      const receipt = reviewClaudeProspectiveCandidate(request2, createHash53("sha256").update(requestBytes).digest("hex"));
+      const receipt = reviewClaudeProspectiveCandidate(request2, createHash54("sha256").update(requestBytes).digest("hex"));
       await writeCliOutput(options.json ? JSON.stringify(receipt) : `Claude plugin candidate review accepted for ${receipt.pluginIds.length} selected plugin(s); native state was not changed.`);
     } catch (error61) {
       console.error(error61 instanceof Error && error61.message.startsWith("CLAUDE_CANDIDATE_REVIEW_REFUSED:") ? error61.message : "CLAUDE_CANDIDATE_REVIEW_REFUSED: request or current preimage validation failed");
@@ -125660,8 +126146,8 @@ function registerAgentIntegration(parent) {
   });
   hook.command("install").option("--agent <agent>", `Agent to configure: ${INTEGRATION_AGENTS.join(", ")}, all (default: configured or detected agents; explicit all requires every adapter)`).option("--command <path>", "Skills executable used by the hook (preserves existing binding; new agents use skills)").option("--selection-profile <id>", "Selection profile (preserves existing binding; new agents use default)").option("--include-vendor", "Retained for compatibility; vendor system skills are always inventoried and disabled", false).option("--discovery-inputs <file>", "Advanced reviewed active plugin roots and source hashes for unsupported registrations").option("--codex-skill-denials <file>", "Explicit reviewed remote skill denials: array of exact name, path and document sha256; requires fresh catalog and discovery inputs").option("--codex-native-catalog <file>", "Reviewed supported Codex skill and installed-plugin receipt for exact qualified-name disables").option("--reviewed-cache-alias <path>", "Exact skill-containing vendor cache alias reviewed for this hook plan").option("--allow-root-aliases", "Allow home .claude/.codex aliases to existing directories within this home", false).option("--apply", "Apply the plan, preserving prior configuration in private backups", false).option("--json", "Output a receipt as JSON", false).description("Plan or install one Skills CLI bridge plus native prompt hooks").action(async (options) => {
     try {
-      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync49(options.discoveryInputs, "utf8")) : undefined;
-      const plan = planAgentIntegration({ projectDir: process.cwd(), agents: options.agent === undefined ? detectedIntegrationAgents() : agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases, reviewedCacheAlias: options.reviewedCacheAlias, codexSkillDenials: options.codexSkillDenials ? JSON.parse(readFileSync49(options.codexSkillDenials, "utf8")) : undefined, codexNativeCatalog: options.codexNativeCatalog ? JSON.parse(readFileSync49(options.codexNativeCatalog, "utf8")) : undefined });
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync50(options.discoveryInputs, "utf8")) : undefined;
+      const plan = planAgentIntegration({ projectDir: process.cwd(), agents: options.agent === undefined ? detectedIntegrationAgents() : agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases, reviewedCacheAlias: options.reviewedCacheAlias, codexSkillDenials: options.codexSkillDenials ? JSON.parse(readFileSync50(options.codexSkillDenials, "utf8")) : undefined, codexNativeCatalog: options.codexNativeCatalog ? JSON.parse(readFileSync50(options.codexNativeCatalog, "utf8")) : undefined });
       const result2 = options.apply ? applyAgentIntegration(plan) : { changed: [], backups: [] };
       const receipt = { codexPluginSkillReview: plan.codexPluginSkillReview, codexPluginSkills: plan.changes.filter((change) => change.path.endsWith("agent-policy.json")).map((change) => JSON.parse(change.after).bridge?.codexPluginSkills ?? []).flat(), applied: options.apply, planned: plan.changes.map((change) => change.path), ...result2, rootAliases: plan.rootAliases ?? [], discovery: plan.discoveryAfter, nativeSkills: plan.nativeSkills.map((entry) => ({ agent: entry.agent, path: entry.path, managed: entry.managed, vendor: entry.vendor, system: entry.system === true, bridge: entry.bridge === true })), requiresNativeRetirement: plan.nativeSkills.some((entry) => !entry.bridge && !entry.system) };
       if (options.json)
@@ -125723,7 +126209,7 @@ function registerAgentIntegration(parent) {
     try {
       if (agents(options.agent).length !== 1)
         throw new Error("A hook invocation requires one agent");
-      const inputBytes = readFileSync49(0), inputText = inputBytes.toString("utf8");
+      const inputBytes = readFileSync50(0), inputText = inputBytes.toString("utf8");
       if (inputText.length > 1024 * 1024)
         throw new Error("Hook input is too large");
       let input3 = JSON.parse(inputText);
@@ -125736,12 +126222,12 @@ function registerAgentIntegration(parent) {
       input3.hook_event_name = event;
       const projects = [process.cwd()];
       if (input3.cwd !== undefined) {
-        if (typeof input3.cwd !== "string" || !isAbsolute49(input3.cwd) || input3.cwd.includes("\x00"))
+        if (typeof input3.cwd !== "string" || !isAbsolute50(input3.cwd) || input3.cwd.includes("\x00"))
           throw new Error("Invalid native hook working directory");
         projects.push(input3.cwd);
       }
       if (options.agent === "cursor") {
-        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path2) => typeof path2 !== "string" || !isAbsolute49(path2) || path2.includes("\x00")))
+        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path2) => typeof path2 !== "string" || !isAbsolute50(path2) || path2.includes("\x00")))
           throw new Error("Invalid Cursor workspace roots");
         projects.push(...input3.workspace_roots);
         input3.cwd ??= input3.workspace_roots[0] ?? process.cwd();
@@ -125889,7 +126375,7 @@ ${driftWarning}` : unavailable2, ...output2 }));
     try {
       if (options.agent && !INTEGRATION_AGENTS.includes(options.agent))
         throw new Error(`Unsupported migration agent: ${options.agent}`);
-      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync49(options.discoveryInputs, "utf8")) : undefined;
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync50(options.discoveryInputs, "utf8")) : undefined;
       if (options.targetManifest && (options.includeUnmanaged || options.includeVendor))
         throw new Error("--target-manifest cannot be combined with broad native migration selectors");
       const targetManifest = options.targetManifest ? readNativeMigrationTargetManifest(options.targetManifest) : undefined;
@@ -126084,7 +126570,7 @@ var exports_profiles = {};
 __export(exports_profiles, {
   registerProfiles: () => registerProfiles
 });
-import { closeSync as closeSync34, constants as constants34, fstatSync as fstatSync33, openSync as openSync34, readSync as readSync27, writeFileSync as writeFileSync30 } from "fs";
+import { closeSync as closeSync34, constants as constants34, fstatSync as fstatSync33, openSync as openSync34, readSync as readSync27, writeFileSync as writeFileSync31 } from "fs";
 function readProfileInput(path2) {
   const fd = openSync34(path2, constants34.O_RDONLY | constants34.O_NONBLOCK);
   try {
@@ -126112,7 +126598,7 @@ function registerProfiles(parent) {
     try {
       const profile = await readSkillProfile(id3), text5 = JSON.stringify(profile, null, 2);
       if (options.save)
-        writeFileSync30(options.save, JSON.stringify(profile), { mode: 384, flag: "wx" });
+        writeFileSync31(options.save, JSON.stringify(profile), { mode: 384, flag: "wx" });
       await writeCliOutput(options.json ? text5 : `${profile.id} at ${profile.revision}: ${profile.selections.map((skill) => `${skill.slug}@${skill.version}`).join(", ")}`);
     } catch (error61) {
       console.error(error61.message);
@@ -126522,7 +127008,7 @@ import {
   fstatSync as fstatSync34,
   openSync as openSync35,
   readSync as readSync28,
-  writeFileSync as writeFileSync31
+  writeFileSync as writeFileSync32
 } from "fs";
 function readInput(path2) {
   const fd = openSync35(path2, constants35.O_RDONLY | constants35.O_NONBLOCK);
@@ -126555,7 +127041,7 @@ function registerGrants(parent) {
     try {
       const policy = await readExecutionGrantPolicy(profile, options.revision);
       if (options.save)
-        writeFileSync31(options.save, JSON.stringify(policy, null, 2), {
+        writeFileSync32(options.save, JSON.stringify(policy, null, 2), {
           mode: 384,
           flag: "wx"
         });
@@ -126582,28 +127068,28 @@ var init_grants = __esm(() => {
 });
 
 // src/lib/station-hydrate.ts
-import { createHash as createHash54 } from "crypto";
+import { createHash as createHash55 } from "crypto";
 import {
   copyFileSync as copyFileSync3,
-  mkdirSync as mkdirSync33,
-  readdirSync as readdirSync30,
-  readFileSync as readFileSync50,
+  mkdirSync as mkdirSync34,
+  readdirSync as readdirSync31,
+  readFileSync as readFileSync51,
   statSync as statSync26,
-  writeFileSync as writeFileSync32
+  writeFileSync as writeFileSync33
 } from "fs";
-import { dirname as dirname53, join as join83, resolve as resolve49, sep as sep24 } from "path";
+import { dirname as dirname54, join as join84, resolve as resolve50, sep as sep25 } from "path";
 function fail7(code2, message, detail = []) {
   throw new StationSnapshotError(code2, message, detail);
 }
 function snapshotRootFor(repoRoot, stationId) {
-  return join83(repoRoot, "resources", stationId, "skills");
+  return join84(repoRoot, "resources", stationId, "skills");
 }
 function readSnapshotManifest(repoRoot, stationId) {
   const snapshotRoot = snapshotRootFor(repoRoot, stationId);
-  const manifestPath = join83(snapshotRoot, "sync-manifest.json");
+  const manifestPath = join84(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync50(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync51(manifestPath, "utf8"));
   } catch (error61) {
     fail7("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error61.message}`);
   }
@@ -126627,10 +127113,10 @@ function planStationHydration(stationId, repoRoot) {
   const hashMismatches = [];
   const skippedByRule = [];
   for (const agent of SYNC_AGENTS) {
-    const agentRoot = join83(snapshotRoot, "agent-homes", agent);
+    const agentRoot = join84(snapshotRoot, "agent-homes", agent);
     let identEntries;
     try {
-      identEntries = readdirSync30(agentRoot, { withFileTypes: true });
+      identEntries = readdirSync31(agentRoot, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -126638,10 +127124,10 @@ function planStationHydration(stationId, repoRoot) {
       if (!identEntry.isDirectory() || identEntry.name.startsWith(".")) {
         continue;
       }
-      const identRoot = join83(agentRoot, identEntry.name);
+      const identRoot = join84(agentRoot, identEntry.name);
       const entries = walkEntries(identRoot);
       for (const entry of entries) {
-        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep24)];
+        const relativeParts = [identEntry.name, ...entry.relativePath.split(sep25)];
         if (entry.kind === "symlink") {
           symlinks.push({ ident: identEntry.name, agent, relativePath: entry.relativePath });
           continue;
@@ -126665,8 +127151,8 @@ function planStationHydration(stationId, repoRoot) {
           });
           continue;
         }
-        const withinIdent = relativeParts.slice(1).join(sep24);
-        const homeRelative = relativeParts.join(sep24);
+        const withinIdent = relativeParts.slice(1).join(sep25);
+        const homeRelative = relativeParts.join(sep25);
         if (REFUSED_SCANNER_FLAGGED.has(homeRelative)) {
           skippedByRule.push({
             ident: identEntry.name,
@@ -126739,7 +127225,7 @@ function planStationHydration(stationId, repoRoot) {
         for (const copy of copies) {
           let isStub = false;
           try {
-            isStub = isPointerSkillMd(readFileSync50(copy.fullPath, "utf8"));
+            isStub = isPointerSkillMd(readFileSync51(copy.fullPath, "utf8"));
           } catch {
             isStub = false;
           }
@@ -126785,12 +127271,12 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash54("sha256").update(joined.sort().join(`
+  return createHash55("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve49(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve49(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve50(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve50(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -126823,7 +127309,7 @@ function writeStationHydration(options) {
   const toWrite = [];
   for (const skill of plan.winners) {
     for (const file2 of skill.files) {
-      const destination = join83(cacheRoot, skill.ident, file2.withinIdent);
+      const destination = join84(cacheRoot, skill.ident, file2.withinIdent);
       const digest7 = sha256File(file2.winner.fullPath);
       let existingDigest = null;
       try {
@@ -126844,7 +127330,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync33(dirname53(entry.destination), { recursive: true });
+    mkdirSync34(dirname54(entry.destination), { recursive: true });
     copyFileSync3(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -126865,9 +127351,9 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join83(dirname53(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync33(dirname53(hydrationManifestPath), { recursive: true });
-  writeFileSync32(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
+  const hydrationManifestPath = join84(dirname54(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync34(dirname54(hydrationManifestPath), { recursive: true });
+  writeFileSync33(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
     ...base3,
@@ -126941,389 +127427,6 @@ var init_hydrate = __esm(() => {
   init_station_hydrate();
 });
 
-// src/lib/prepare-skill.ts
-import { createHash as createHash55, randomUUID as randomUUID17 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync54, mkdirSync as mkdirSync34, mkdtempSync as mkdtempSync7, readFileSync as readFileSync51, readdirSync as readdirSync31, renameSync as renameSync18, rmSync as rmSync10, writeFileSync as writeFileSync33 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname54, isAbsolute as isAbsolute50, join as join84, relative as relative17, resolve as resolve50, sep as sep25 } from "path";
-function prepareSkill(name, options) {
-  const normalized2 = normalizePortableSkillName(name);
-  if (!new RegExp(SEMVER_PATTERN).test(options.version))
-    throw new Error("--version must be a semantic version, for example 0.2.0.");
-  const path2 = join84(getPortableSkillsRootReadOnly(options), normalized2);
-  assertPortableAuthoringPath(path2, options);
-  const before2 = snapshot2(path2);
-  const manifestFile = before2.files.find((file2) => file2.path === "skill.json");
-  if (!manifestFile)
-    throw new Error(`Skill '${normalized2}' needs skill.json. Import the source with skills port first.`);
-  let manifest;
-  try {
-    const parsed = JSON.parse(manifestFile.bytes.toString("utf8"));
-    if (!isRecord9(parsed))
-      throw new Error("not an object");
-    manifest = parsed;
-  } catch {
-    throw new Error("skill.json must contain a JSON object; no files were changed.");
-  }
-  const previousVersion = manifest.version;
-  if (typeof previousVersion !== "string" || !new RegExp(SEMVER_PATTERN).test(previousVersion)) {
-    throw new Error("skill.json must declare its current semantic version before preparation.");
-  }
-  if (manifest.kind !== undefined && manifest.kind !== "instruction" && manifest.kind !== "executable") {
-    throw new Error("skill.json has an invalid kind; correct it before preparation.");
-  }
-  const kind = options.kind ?? manifest.kind;
-  if (kind !== "instruction" && kind !== "executable") {
-    throw new Error("This legacy manifest has no explicit kind. Pass --kind instruction or --kind executable; helper scripts alone do not determine a skill's kind.");
-  }
-  const document3 = before2.files.find((file2) => file2.path === "SKILL.md");
-  const documentKind = document3 ? parseSkillFrontmatter(document3.bytes.toString("utf8"))?.kind : undefined;
-  if (documentKind !== undefined && documentKind !== kind) {
-    throw new Error("SKILL.md kind conflicts with the candidate skill.json kind. Review and align both declarations (or remove the optional frontmatter kind), then prepare again; no files were changed.");
-  }
-  if (manifest.provenance !== undefined && !isRecord9(manifest.provenance))
-    throw new Error("skill.json provenance must be an object.");
-  const provenance = manifest.provenance;
-  const candidate2 = { ...manifest, version: options.version, kind, provenance: { ...provenance } };
-  const staging = mkdtempSync7(join84(tmpdir2(), "skills-prepare-"));
-  try {
-    for (const directory3 of before2.directories)
-      mkdirSync34(join84(staging, directory3), { recursive: true });
-    for (const file2 of before2.files) {
-      const destination = join84(staging, file2.path);
-      mkdirSync34(dirname54(destination), { recursive: true });
-      writeFileSync33(destination, file2.bytes, { mode: file2.mode });
-    }
-    const stagedManifest = join84(staging, "skill.json");
-    writeFileSync33(stagedManifest, `${JSON.stringify(candidate2, null, 2)}
-`);
-    const contentHash = computeContentHash(staging);
-    const changed3 = options.version !== previousVersion || kind !== manifest.kind || contentHash !== provenance?.content_hash;
-    if (changed3 && compareVersions(options.version, previousVersion) <= 0) {
-      throw new Error(`Changed content requires a version greater than ${previousVersion}; pass --version <new-semver>.`);
-    }
-    candidate2.provenance.content_hash = contentHash;
-    const candidateBytes = `${JSON.stringify(candidate2, null, 2)}
-`;
-    writeFileSync33(stagedManifest, candidateBytes);
-    validateRawCandidate(candidate2);
-    validateRuntimeEntrypoint(candidate2, staging);
-    const validation = validatePortableSkillDirectory(normalized2, staging);
-    if (!validation.valid)
-      throw new Error(`Skill '${normalized2}' cannot be prepared:
-${validation.issues.map((issue2) => `${issue2.code}: ${issue2.message}`).join(`
-`)}`);
-    assertPackedCanonicalCoverage(staging);
-    if (snapshot2(path2).identity !== before2.identity)
-      throw new Error("Skill changed during preparation; review the draft and run prepare again.");
-    if (changed3 && !options.dryRun) {
-      const temporary = join84(path2, `.skill-prepare-${randomUUID17()}.tmp`);
-      try {
-        writeFileSync33(temporary, candidateBytes, { flag: "wx", mode: manifestFile.mode });
-        chmodSync5(temporary, manifestFile.mode);
-        renameSync18(temporary, join84(path2, "skill.json"));
-      } finally {
-        rmSync10(temporary, { force: true });
-      }
-    }
-    return { name: normalized2, path: path2, previousVersion, version: options.version, kind, contentHash, changed: changed3, written: changed3 && !options.dryRun, warnings: validation.warnings };
-  } finally {
-    rmSync10(staging, { recursive: true, force: true });
-  }
-}
-function assertPackedCanonicalCoverage(root2) {
-  const canonicalPaths = new Set(collectBundleFiles(root2).map((file2) => file2.rel));
-  const packedPaths = new Set(collectSkillBundleEntries(root2).map((entry) => entry.path));
-  const omitted = [...canonicalPaths].filter((path2) => !packedPaths.has(path2)).sort();
-  if (omitted.length === 0)
-    return;
-  const rendered = omitted.slice(0, MAX_PACK_PARITY_PATHS).map(escapedRelativePath).join(", ");
-  const suffix = omitted.length > MAX_PACK_PARITY_PATHS ? ` (+${omitted.length - MAX_PACK_PARITY_PATHS} more)` : "";
-  throw new Error(`Skill cannot be prepared because packSkillBundle excludes canonical source path(s): ${rendered}${suffix}. ` + "Rename or remove the excluded source before preparing; no files were changed.");
-}
-function escapedRelativePath(path2) {
-  const bounded2 = path2.length > MAX_PACK_PARITY_PATH_CHARS - 8 ? `${path2.slice(0, MAX_PACK_PARITY_PATH_CHARS - 8)}...` : path2;
-  return JSON.stringify(bounded2);
-}
-function validateRuntimeEntrypoint(candidate2, root2) {
-  if (candidate2.kind !== "executable" || !isRecord9(candidate2.runtime))
-    return;
-  const entry = candidate2.runtime.entrypoint;
-  if (typeof entry !== "string")
-    return;
-  const target = resolve50(root2, entry), rel = relative17(root2, target);
-  if (isAbsolute50(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep25}`) || isAbsolute50(rel) || !existsSync37(target) || !lstatSync54(target).isFile()) {
-    throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
-  }
-}
-function isRecord9(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateRawCandidate(candidate2) {
-  for (const field4 of ["standard", "name", "description", "version"]) {
-    if (typeof candidate2[field4] !== "string" || !candidate2[field4].trim())
-      throw new Error(`skill.json ${field4} is required.`);
-  }
-  for (const field4 of ["displayName", "category"]) {
-    if (candidate2[field4] !== undefined && (typeof candidate2[field4] !== "string" || !candidate2[field4].trim()))
-      throw new Error(`Invalid skill.json ${field4}.`);
-  }
-  if (candidate2.tags !== undefined && (!Array.isArray(candidate2.tags) || candidate2.tags.some((tag) => typeof tag !== "string" || !tag.trim())))
-    throw new Error("Invalid skill.json tags.");
-  const issues = validatePortableManifestContract(candidate2, { strict: true });
-  if (issues.length)
-    throw new Error(`Invalid skill.json: ${issues.map((issue2) => issue2.code).join(", ")}`);
-  validateRuntimeEntrypointCompatibility(candidate2);
-  for (const field4 of ["inputs", "commands"]) {
-    const items = candidate2[field4];
-    if (items === undefined)
-      continue;
-    if (!Array.isArray(items))
-      throw new Error(`skill.json ${field4} must be an array.`);
-    for (const item of items) {
-      if (!isRecord9(item) || typeof item.name !== "string" || !item.name.trim())
-        throw new Error(`Invalid skill.json ${field4} name.`);
-      if (field4 === "inputs" && (typeof item.type !== "string" || !item.type.trim() || item.required !== undefined && typeof item.required !== "boolean"))
-        throw new Error("Invalid skill.json input type or required flag.");
-      if (field4 === "commands") {
-        if (!/^[a-z0-9][a-z0-9._-]*$/.test(item.name))
-          throw new Error("Invalid skill.json command name.");
-        for (const target of ["entry", "command"])
-          if (item[target] !== undefined && (typeof item[target] !== "string" || !item[target].trim()))
-            throw new Error(`Invalid skill.json command ${target}.`);
-        if (!item.entry && !item.command)
-          throw new Error("A skill.json command needs entry or command.");
-        if (item.args !== undefined && (!Array.isArray(item.args) || item.args.some((arg) => typeof arg !== "string")))
-          throw new Error("Invalid skill.json command args.");
-      }
-    }
-  }
-}
-function validateRuntimeEntrypointCompatibility(candidate2) {
-  if (candidate2.kind !== "executable" || !isRecord9(candidate2.runtime))
-    return;
-  const runtime = candidate2.runtime.runtime;
-  const entrypoint = candidate2.runtime.entrypoint;
-  if (typeof runtime !== "string" || typeof entrypoint !== "string")
-    return;
-  const extension = entrypoint.toLowerCase().split(".").pop();
-  if (extension === "py" && runtime !== "python3") {
-    throw new Error("Invalid skill.json: runtime.entrypoint with .py extension requires runtime python3.");
-  }
-}
-function compareVersions(left, right) {
-  const parts = (value) => value.split("+")[0].split(/-(.*)/s).slice(0, 2);
-  const [a, ap] = parts(left), [b, bp] = parts(right);
-  const ac = a.split(".").map(BigInt), bc = b.split(".").map(BigInt);
-  for (let i = 0;i < 3; i++)
-    if (ac[i] !== bc[i])
-      return ac[i] > bc[i] ? 1 : -1;
-  if (ap === undefined || bp === undefined)
-    return ap === bp ? 0 : ap === undefined ? 1 : -1;
-  const aa = ap.split("."), bb = bp.split(".");
-  for (let i = 0;i < Math.max(aa.length, bb.length); i++) {
-    const x = aa[i], y = bb[i];
-    if (x === undefined || y === undefined)
-      return x === y ? 0 : x === undefined ? -1 : 1;
-    if (x === y)
-      continue;
-    const xn = /^\d+$/.test(x), yn = /^\d+$/.test(y);
-    if (xn && yn)
-      return BigInt(x) > BigInt(y) ? 1 : -1;
-    if (xn !== yn)
-      return xn ? -1 : 1;
-    return x > y ? 1 : -1;
-  }
-  return 0;
-}
-function snapshot2(root2) {
-  const rootStat = lstatSync54(root2);
-  if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
-    throw new Error("Skill root must be a real directory, not a symlink.");
-  const files = [], directories = [];
-  const hash8 = createHash55("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
-  let count = 0, bytes = 0;
-  const walk2 = (relative18) => {
-    for (const name of readdirSync31(join84(root2, relative18)).sort()) {
-      if (IGNORED.has(name.toLowerCase()) || !relative18 && ROOT_IGNORED.has(name.toLowerCase()))
-        continue;
-      const path2 = relative18 ? `${relative18}/${name}` : name;
-      if (++count > 20000)
-        throw new Error("Skill exceeds the preparation entry limit (20000).");
-      const absolute = join84(root2, path2), stat3 = lstatSync54(absolute);
-      if (stat3.isSymbolicLink())
-        throw new Error(`Skill contains a symlink: ${path2}. No files were changed.`);
-      if (stat3.isDirectory() && name === "node_modules")
-        continue;
-      hash8.update(JSON.stringify([path2, stat3.dev, stat3.ino, stat3.mode]));
-      if (stat3.isDirectory()) {
-        directories.push(path2);
-        walk2(path2);
-      } else if (stat3.isFile()) {
-        bytes += stat3.size;
-        if (bytes > 50000000)
-          throw new Error("Skill exceeds the preparation size limit (50000000 bytes).");
-        const content = readFileSync51(absolute);
-        if (content.length !== stat3.size)
-          throw new Error("Skill changed during preparation.");
-        files.push({ path: path2, bytes: content, mode: stat3.mode & 511 });
-        hash8.update(`\x00${content.length}\x00`).update(content);
-      } else
-        throw new Error(`Unsupported skill entry: ${path2}.`);
-      hash8.update("\x00");
-    }
-  };
-  walk2("");
-  return { files, directories, identity: hash8.digest("hex") };
-}
-var MAX_PACK_PARITY_PATHS = 8, MAX_PACK_PARITY_PATH_CHARS = 120, IGNORED, ROOT_IGNORED;
-var init_prepare_skill = __esm(() => {
-  init_portable_skills();
-  init_skill_contract();
-  init_skill_hash();
-  init_skill_bundle();
-  init_skill_validation();
-  init_authoring_path();
-  IGNORED = new Set([".git", ".ds_store", ".system"]);
-  ROOT_IGNORED = new Set(["dist", "build", ".turbo", ".skills-dependency-preparation"]);
-});
-
-// src/cli/commands/portable-skills.ts
-var exports_portable_skills = {};
-__export(exports_portable_skills, {
-  registerPortableSkillCommands: () => registerPortableSkillCommands
-});
-function registerPortableSkillCommands(parent) {
-  parent.command("prepare").argument("<name>", "Name of a skill in the local corpus").requiredOption("--version <version>", "Reviewed semantic version for this draft").option("--kind <kind>", "Explicit instruction or executable kind; required for legacy kind-less manifests").option("--dry-run", "Validate the candidate and report its hash without changing the draft", false).option("--json", "Output result as JSON", false).description("Validate a reviewed draft and update its manifest version and content hash").action(async (name, options) => {
-    try {
-      const result2 = prepareSkill(name, { ...options, kind: options.kind === undefined ? undefined : parseSkillKind2(options.kind) });
-      if (result2.written)
-        clearRegistryCache();
-      if (options.json)
-        await writeCliOutput(JSON.stringify(result2, null, 2));
-      else {
-        console.log(source_default.green(`${result2.written ? "Prepared" : options.dryRun ? "Previewed" : "Already prepared"} ${result2.name}@${result2.version} (${result2.kind})`));
-        console.log(source_default.dim(`  Content hash: ${result2.contentHash}`));
-        console.log(source_default.dim(`  Manifest: ${result2.path}/skill.json`));
-        if (result2.written)
-          console.log(source_default.dim(`  Publish: skills push ${result2.name}`));
-      }
-    } catch (error61) {
-      if (options.json)
-        await writeCliOutput(JSON.stringify({ error: error61.message }, null, 2));
-      else
-        console.error(source_default.red(error61.message));
-      process.exitCode = 1;
-    }
-  });
-  parent.command("new").alias("scaffold").argument("<name>", "Portable skill name").option("--description <description>", "Short description of what the skill does").option("--kind <kind>", "Skill class: executable (default) or instruction (prose only)", "executable").option("-o, --overwrite", "Replace an existing portable skill folder", false).option("--json", "Output result as JSON", false).description("Scaffold a portable skill under ~/.hasna/skills/installed/<name>").action((name, options) => {
-    try {
-      const kind = parseSkillKind2(options.kind);
-      const result2 = scaffoldPortableSkill(name, {
-        description: options.description,
-        overwrite: options.overwrite,
-        kind
-      });
-      clearRegistryCache();
-      if (options.json) {
-        console.log(JSON.stringify({ ...result2, manifest: result2.manifest }, null, 2));
-        return;
-      }
-      console.log(source_default.green(`\u2713 Created ${kind} skill '${result2.name}'`));
-      console.log(source_default.dim(`  Path: ${result2.path}`));
-      if (kind === "instruction") {
-        console.log(source_default.dim(`  Edit the prose in: ${result2.path}/SKILL.md`));
-        console.log(source_default.dim(`  Instruction skills are consumed by agents, not run with 'skills run'.`));
-      } else {
-        console.log(source_default.dim(`  Agent instructions: ${result2.path}/AGENTS.md`));
-        console.log(source_default.dim(`  Validate: skills validate ${result2.name}`));
-        console.log(source_default.dim(`  Run: skills run ${result2.name} --help`));
-      }
-    } catch (error61) {
-      writePortableError(error61, options.json);
-    }
-  });
-  parent.command("port").alias("add").argument("<path>", "Existing skill folder (or parent directory with --all) to import").option("--name <name>", "Override the imported skill name").option("--all", "Import every skill subfolder of <path> (bulk import)", false).option("-o, --overwrite", "Replace an existing portable skill folder", false).option("--allow-shadow", "Allow an imported name that shadows a bundled official skill", false).option("--json", "Output result as JSON", false).description("Import an existing skill folder into ~/.hasna/skills/installed/<name>").action((path2, options) => {
-    if (options.all) {
-      handleBulkPort(path2, options);
-      return;
-    }
-    try {
-      const result2 = portPortableSkill(path2, {
-        name: options.name,
-        overwrite: options.overwrite,
-        allowShadow: options.allowShadow
-      });
-      clearRegistryCache();
-      const validation = validatePortableSkillDirectory(result2.name, result2.path);
-      const payload = { ...result2, valid: validation.valid, issues: validation.issues, warnings: validation.warnings };
-      if (!validation.valid)
-        process.exitCode = 1;
-      if (options.json) {
-        console.log(JSON.stringify(payload, null, 2));
-        return;
-      }
-      console.log(validation.valid ? source_default.green(`\u2713 Ported portable skill '${result2.name}'`) : source_default.yellow(`Validation failed for imported files '${result2.name}'; correct the folder before using it.`));
-      console.log(source_default.dim(`  Path: ${result2.path}`));
-      console.log(source_default.dim(`  Valid: ${validation.valid ? "yes" : "no"}`));
-      if (!validation.valid) {
-        for (const issue2 of validation.issues)
-          console.log(source_default.red(`  \u2022 ${issue2.message}`));
-      }
-    } catch (error61) {
-      writePortableError(error61, options.json);
-    }
-  });
-}
-function handleBulkPort(path2, options) {
-  if (options.name) {
-    writePortableError(new Error("--name cannot be used with --all"), options.json);
-    return;
-  }
-  try {
-    const summary = portPortableSkillDirectory(path2, { overwrite: options.overwrite, allowShadow: options.allowShadow });
-    clearRegistryCache();
-    if (options.json) {
-      console.log(JSON.stringify(summary, null, 2));
-      if (summary.failed > 0)
-        process.exitCode = 1;
-      return;
-    }
-    console.log(source_default.green(`\u2713 Imported ${summary.succeeded}/${summary.total} skill(s) from ${summary.root}`));
-    for (const entry of summary.imported)
-      console.log(source_default.dim(`  \u2022 ${entry.name} \u2192 ${entry.path}`));
-    if (summary.skipped.length > 0) {
-      console.log(source_default.yellow(`  Skipped ${summary.skipped.length}:`));
-      for (const entry of summary.skipped)
-        console.log(source_default.yellow(`  \u2022 ${entry.sourcePath}: ${entry.reason}`));
-      process.exitCode = 1;
-    }
-  } catch (error61) {
-    writePortableError(error61, options.json);
-  }
-}
-function parseSkillKind2(value) {
-  if (value === undefined || value === "executable")
-    return "executable";
-  if (value === "instruction")
-    return "instruction";
-  throw new Error(`Invalid --kind '${value}'. Use 'executable' or 'instruction'.`);
-}
-function writePortableError(error61, json3) {
-  const message = error61.message;
-  if (json3)
-    console.log(JSON.stringify({ error: message }, null, 2));
-  else
-    console.error(source_default.red(message));
-  process.exitCode = 1;
-}
-var init_portable_skills2 = __esm(() => {
-  init_source();
-  init_registry();
-  init_prepare_skill();
-  init_portable_skills();
-});
-
 // src/cli/commands/metadata.ts
 var exports_metadata = {};
 __export(exports_metadata, {