@hasna/skills 0.9.9 → 0.9.11

package/dist/sdk/index.js

@@ -9004,7 +9004,7 @@ var require_client = __commonJS((exports) => {
 var require_config = __commonJS((exports) => {
   var { homedir: homedir6 } = __require("os");
   var { sep: sep7, join: join4 } = __require("path");
-  var { createHash: createHash17 } = __require("crypto");
+  var { createHash: createHash19 } = __require("crypto");
   var { readFile: readFile$1 } = __require("fs/promises");
   var { IniSectionType } = require_dist_cjs();
   var { normalizeProvider } = require_client();
@@ -9159,7 +9159,7 @@ var require_config = __commonJS((exports) => {
   var DEFAULT_PROFILE = "default";
   var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
   var getSSOTokenFilepath = (id2) => {
-    const hasher = createHash17("sha1");
+    const hasher = createHash19("sha1");
     const cacheName = hasher.update(id2).digest("hex");
     return join4(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
   };
@@ -9311,11 +9311,11 @@ var require_config = __commonJS((exports) => {
   };
   function getSelectorName(functionString) {
     try {
-      const constants12 = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
-      constants12.delete("CONFIG");
-      constants12.delete("CONFIG_PREFIX_SEPARATOR");
-      constants12.delete("ENV");
-      return [...constants12].join(", ");
+      const constants13 = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
+      constants13.delete("CONFIG");
+      constants13.delete("CONFIG_PREFIX_SEPARATOR");
+      constants13.delete("ENV");
+      return [...constants13].join(", ");
     } catch (ignored) {
       return functionString;
     }
@@ -10511,10 +10511,10 @@ var require_endpoints = __commonJS((exports) => {
 
 // node_modules/@smithy/core/dist-cjs/submodules/serde/index.js
 var require_serde = __commonJS((exports) => {
-  var { createHmac: createHmac2, createHash: createHash17, getRandomValues } = __require("crypto");
+  var { createHmac: createHmac2, createHash: createHash19, getRandomValues } = __require("crypto");
   var { hasOwn: hasOwn2, HttpResponse } = require_transport();
   exports.hasOwn = hasOwn2;
-  var { ReadStream, lstatSync: lstatSync20, fstatSync: fstatSync4 } = __require("fs");
+  var { ReadStream, lstatSync: lstatSync21, fstatSync: fstatSync4 } = __require("fs");
   var { toEndpointV1 } = require_endpoints();
   var { Readable, Writable, PassThrough } = __require("stream");
   var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
@@ -11280,7 +11280,7 @@ var require_serde = __commonJS((exports) => {
       return body.end + 1 - body.start;
     } else if (body instanceof ReadStream) {
       if (body.path != null) {
-        return lstatSync20(body.path).size;
+        return lstatSync21(body.path).size;
       } else if (typeof body.fd === "number") {
         return fstatSync4(body.fd).size;
       }
@@ -11416,7 +11416,7 @@ var require_serde = __commonJS((exports) => {
       return Promise.resolve(this.hash.digest());
     }
     reset() {
-      this.hash = this.secret ? createHmac2(this.algorithmIdentifier, castSourceData(this.secret)) : createHash17(this.algorithmIdentifier);
+      this.hash = this.secret ? createHmac2(this.algorithmIdentifier, castSourceData(this.secret)) : createHash19(this.algorithmIdentifier);
     }
   }
   function castSourceData(toCast, encoding) {
@@ -12155,7 +12155,7 @@ var require_checksum = __commonJS((exports) => {
   var { createReadStream } = __require("fs");
   var { Writable } = __require("stream");
   var { toUint8Array, concatBytes } = require_serde();
-  var { createHash: createHash17, createHmac: createHmac2 } = __require("crypto");
+  var { createHash: createHash19, createHmac: createHmac2 } = __require("crypto");
   var zlib = __require("zlib");
   async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
     const size = blob.size;
@@ -12320,7 +12320,7 @@ var require_checksum = __commonJS((exports) => {
   }
   var hasNativeCrypto$1 = (() => {
     try {
-      createHash17("md5");
+      createHash19("md5");
       return true;
     } catch {
       return false;
@@ -12330,7 +12330,7 @@ var require_checksum = __commonJS((exports) => {
   function buildNativeClass$2() {
     return class Md5Node2 {
       digestLength = 16;
-      hash = createHash17("md5");
+      hash = createHash19("md5");
       update(data) {
         this.hash.update(toUint8Array(data));
       }
@@ -12339,7 +12339,7 @@ var require_checksum = __commonJS((exports) => {
         return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
       }
       reset() {
-        this.hash = createHash17("md5");
+        this.hash = createHash19("md5");
       }
     };
   }
@@ -12629,7 +12629,7 @@ var require_checksum = __commonJS((exports) => {
   ]);
   var hasNativeCrypto = (() => {
     try {
-      createHash17("sha256");
+      createHash19("sha256");
       return true;
     } catch {
       return false;
@@ -12669,7 +12669,7 @@ var require_checksum = __commonJS((exports) => {
         this.finished = false;
       }
       createHash() {
-        return this.secret ? createHmac2("sha256", toBuffer(this.secret)) : createHash17("sha256");
+        return this.secret ? createHmac2("sha256", toBuffer(this.secret)) : createHash19("sha256");
       }
     };
   }
@@ -25679,7 +25679,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
       return this.connectOptions === undefined ? http2.connect(url) : http2.connect(url, this.connectOptions);
     }
   }
-  var { constants: constants12 } = http2;
+  var { constants: constants13 } = http2;
 
   class NodeHttp2Handler {
     config;
@@ -25770,8 +25770,8 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         }
         const clientHttp2Stream = session.request({
           ...request2.headers,
-          [constants12.HTTP2_HEADER_PATH]: path,
-          [constants12.HTTP2_HEADER_METHOD]: method
+          [constants13.HTTP2_HEADER_PATH]: path,
+          [constants13.HTTP2_HEADER_METHOD]: method
         });
         if (effectiveRequestTimeout) {
           clientHttp2Stream.setTimeout(effectiveRequestTimeout, () => {
@@ -29443,10 +29443,10 @@ var require_signin = __commonJS((exports) => {
 });
 
 // node_modules/@aws-sdk/credential-provider-ini/node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js
-import { createHash as createHash17, createPrivateKey, createPublicKey, sign } from "crypto";
+import { createHash as createHash19, createPrivateKey, createPublicKey, sign } from "crypto";
 import { promises as fs2 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname18, join as join31 } from "path";
+import { dirname as dirname19, join as join31 } from "path";
 var import_config27, import_protocols3, LoginCredentialsFetcher;
 var init_LoginCredentialsFetcher = __esm(() => {
   import_config27 = __toESM(require_config(), 1);
@@ -29606,7 +29606,7 @@ var init_LoginCredentialsFetcher = __esm(() => {
     }
     async saveToken(token) {
       const tokenFilePath = this.getTokenFilePath();
-      const directory = dirname18(tokenFilePath);
+      const directory = dirname19(tokenFilePath);
       try {
         await fs2.mkdir(directory, { recursive: true });
       } catch (error) {}
@@ -29615,7 +29615,7 @@ var init_LoginCredentialsFetcher = __esm(() => {
     getTokenFilePath() {
       const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join31(homedir6(), ".aws", "login", "cache");
       const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
-      const loginSessionSha256 = createHash17("sha256").update(loginSessionBytes).digest("hex");
+      const loginSessionSha256 = createHash19("sha256").update(loginSessionBytes).digest("hex");
       return join31(directory, `${loginSessionSha256}.json`);
     }
     derToRawSignature(derSignature) {
@@ -32373,7 +32373,7 @@ var init_event_sink = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.9.9",
+  version: "0.9.11",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -37210,10 +37210,10 @@ async function reconcileSkillSession(input, options = {}) {
   return { applied: true, plan, planDigest, ...result };
 }
 // src/lib/selected-run.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { spawn } from "child_process";
-import { mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync8, realpathSync as realpathSync7 } from "fs";
-import { dirname as dirname17, join as join30, resolve as resolve16 } from "path";
+import { mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync9, realpathSync as realpathSync7 } from "fs";
+import { dirname as dirname18, join as join30, resolve as resolve16 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 
 // src/lib/dependency-preparation.ts
@@ -37436,7 +37436,7 @@ import { homedir as homedir5 } from "os";
 import {
   cpSync as cpSync2,
   existsSync as existsSync10,
-  lstatSync as lstatSync19,
+  lstatSync as lstatSync20,
   mkdirSync as mkdirSync8,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync16,
@@ -37444,15 +37444,15 @@ import {
   renameSync as renameSync5,
   rmSync as rmSync3,
   statSync as statSync9,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename9, dirname as dirname16, join as join25 } from "path";
+import { basename as basename9, dirname as dirname17, join as join25 } from "path";
 
 // src/lib/agent-integration.ts
-import { createHash as createHash14, randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync6, lstatSync as lstatSync17, statSync as statSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync13, readdirSync as readdirSync7, opendirSync as opendirSync5, readlinkSync as readlinkSync2, realpathSync as realpathSync4, renameSync as renameSync3, rmdirSync as rmdirSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync4, chmodSync, openSync as openSync15, closeSync as closeSync15, fsyncSync as fsyncSync3, fstatSync as fstatSync15, readSync as readSync10, constants as constants11, linkSync as linkSync2 } from "fs";
-import { dirname as dirname13, join as join21, resolve as resolve14, relative as relative3, isAbsolute as isAbsolute15, sep as sep4 } from "path";
+import { createHash as createHash16, randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync6, lstatSync as lstatSync18, statSync as statSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync13, readdirSync as readdirSync7, opendirSync as opendirSync5, readlinkSync as readlinkSync2, realpathSync as realpathSync4, renameSync as renameSync3, rmdirSync as rmdirSync3, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4, chmodSync, openSync as openSync16, closeSync as closeSync16, fsyncSync as fsyncSync4, fstatSync as fstatSync16, readSync as readSync11, constants as constants12, linkSync as linkSync2 } from "fs";
+import { dirname as dirname14, join as join21, resolve as resolve14, relative as relative3, isAbsolute as isAbsolute15, sep as sep4 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/lib/managed-policy.ts
@@ -37682,9 +37682,9 @@ function isOwnedCliBridge(path, expectedPaths) {
 }
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash13 } from "crypto";
-import { lstatSync as lstatSync16, readFileSync as readFileSync12, readdirSync as readdirSync6, realpathSync as realpathSync3 } from "fs";
-import { basename as basename6, dirname as dirname12, isAbsolute as isAbsolute14, join as join20, resolve as resolve13, sep as sep3 } from "path";
+import { createHash as createHash15 } from "crypto";
+import { lstatSync as lstatSync17, readFileSync as readFileSync12, readdirSync as readdirSync6, realpathSync as realpathSync3 } from "fs";
+import { basename as basename6, dirname as dirname13, isAbsolute as isAbsolute14, join as join20, resolve as resolve13, sep as sep3 } from "path";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -40084,8 +40084,76 @@ function captureClaudeSettings(path, budget = { remaining: 256 * 1024 * 1024 })
   return { path, hashMode: "claude-settings-v1", sha256: settingsDigest(readSettings(path, budget)) };
 }
 
+// src/lib/codex-hook-discovery-recovery.ts
+import { createHash as createHash14 } from "crypto";
+
+// src/lib/codex-hook-trust-files.ts
+import { closeSync as closeSync15, constants as constants11, fstatSync as fstatSync15, fsyncSync as fsyncSync3, lstatSync as lstatSync16, openSync as openSync15, readSync as readSync10, writeFileSync as writeFileSync3 } from "fs";
+import { createHash as createHash13 } from "crypto";
+import { dirname as dirname12 } from "path";
+function need4(value, code) {
+  if (!value)
+    throw new Error(`CODEX_HOOK_TRUST_${code}`);
+}
+var sameStat = (a, b) => ["dev", "ino", "uid", "nlink", "mode", "size", "mtimeNs", "ctimeNs"].every((key) => a[key] === b[key]);
+function safeParents(file) {
+  for (let p = dirname12(file);; p = dirname12(p)) {
+    const s = lstatSync16(p);
+    need4(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
+    need4((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
+    if (dirname12(p) === p)
+      break;
+  }
+}
+function snapshot(file, privateFile = false, options = {}) {
+  const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
+  safeParents(file);
+  const initial = lstatSync16(file, { bigint: true });
+  need4(initial.isFile() && initial.uid === BigInt(process.getuid()) && (initial.nlink === 1n || readOnlyPackage && initial.nlink > 1n) && (initial.mode & 0o022n) === 0n && (!privateFile || (initial.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
+  need4(initial.size <= 8n * 1024n * 1024n, "FILE_BOUND");
+  const fd = openSync15(file, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  try {
+    const before = fstatSync15(fd, { bigint: true });
+    need4(sameStat(initial, before), "INPUT_CHANGED");
+    const bytes = Buffer.alloc(Number(before.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const n2 = readSync10(fd, bytes, length, bytes.length - length, null);
+      if (!n2)
+        break;
+      length += n2;
+    }
+    need4(length === Number(before.size) && sameStat(before, fstatSync15(fd, { bigint: true })) && sameStat(before, lstatSync16(file, { bigint: true })), "INPUT_CHANGED");
+    const content = bytes.subarray(0, length), text2 = new TextDecoder("utf-8", { fatal: true }).decode(content);
+    return { file, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash13("sha256").update(content).digest("hex") };
+  } finally {
+    closeSync15(fd);
+  }
+}
+function unchanged2(before) {
+  const after = snapshot(before.file, before.privateFile, before.readOnlyPackage ? { readOnlyPackage: true } : {});
+  need4(sameStat(before.stat, after.stat) && after.sha256 === before.sha256, "INPUT_CHANGED");
+}
+
+// src/lib/codex-hook-discovery-recovery.ts
+var sha = (text2) => createHash14("sha256").update(text2).digest("hex");
+var proofs = new WeakMap;
+function assertCodexHookDiscoveryRecovery(binding, witness) {
+  const proof = proofs.get(witness);
+  need4(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  unchanged2(proof.before);
+  unchanged2(proof.current);
+}
+function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witness) {
+  if (!witness || source.path !== witness.configPath || source.hashMode !== "bytes")
+    return false;
+  assertCodexHookDiscoveryRecovery(binding, witness);
+  need4(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
+  return true;
+}
+
 // src/lib/agent-discovery.ts
-var digest2 = (text2) => createHash13("sha256").update(text2).digest("hex");
+var digest2 = (text2) => createHash15("sha256").update(text2).digest("hex");
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -40099,10 +40167,10 @@ function parseConfig(text2, path, toml = false) {
 function safe4(path) {
   if (!isAbsolute14(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
-  for (let cursor = path;; cursor = dirname12(cursor)) {
-    if (lstatSync16(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+  for (let cursor = path;; cursor = dirname13(cursor)) {
+    if (lstatSync17(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname12(cursor) === cursor)
+    if (dirname13(cursor) === cursor)
       break;
   }
 }
@@ -40110,7 +40178,7 @@ function read(path, changes) {
   safe4(path);
   if (changes?.has(path))
     return changes.get(path);
-  const stat2 = lstatSync16(path, { throwIfNoEntry: false });
+  const stat2 = lstatSync17(path, { throwIfNoEntry: false });
   if (!stat2)
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
@@ -40160,7 +40228,9 @@ function projected(source, changes, budget = discoveryByteBudget()) {
     throw new Error("Expected native discovery configuration object");
   return digest2(JSON.stringify(Object.fromEntries((source.fields ?? []).map((field2) => [field2, object4[field2] ?? null]))));
 }
-function verifyAgentDiscovery(binding) {
+function verifyAgentDiscovery(binding, codexRecovery) {
+  if (codexRecovery)
+    assertCodexHookDiscoveryRecovery(binding, codexRecovery);
   if (!binding || !Array.isArray(binding.sources) || !Array.isArray(binding.roots) || binding.sources.length > AGENT_POLICY_LIMITS.discoverySources || binding.roots.length > AGENT_POLICY_LIMITS.discoveryRoots)
     throw new Error("Invalid native discovery binding");
   if (binding.agent === "hermes" && !binding.directories?.length)
@@ -40176,7 +40246,8 @@ function verifyAgentDiscovery(binding) {
       throw new Error("Invalid native discovery projection");
     if (source.sha256 !== null && !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Invalid native discovery digest");
-    if (projected(source, undefined, budget) !== source.sha256)
+    const current = projected(source, undefined, budget);
+    if (current !== source.sha256 && !verifiesCodexHookDiscoverySource(binding, source, current, codexRecovery))
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
   }
   for (const root2 of binding.roots)
@@ -40248,21 +40319,21 @@ function resolveAgentDiscovery(options) {
     const executable = Bun.which("gemini");
     if (executable) {
       let packageRoot;
-      for (let directory = dirname12(realpathSync3(executable)), depth = 0;depth < 8; directory = dirname12(directory), depth++) {
+      for (let directory = dirname13(realpathSync3(executable)), depth = 0;depth < 8; directory = dirname13(directory), depth++) {
         const path = join20(directory, "package.json"), raw = read(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname12(directory) === directory)
+        if (dirname13(directory) === directory)
           break;
       }
       if (!packageRoot)
         unresolved("installed Gemini package layout is not recognized");
       const builtinRoot = join20(packageRoot, "bundle/builtin");
       safe4(builtinRoot);
-      if (!lstatSync16(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
+      if (!lstatSync17(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
       for (const name of readdirSync6(builtinRoot).sort()) {
         const text2 = witness(join20(builtinRoot, name, "SKILL.md"));
@@ -40302,7 +40373,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join20(root2, "commands");
     safe4(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync16(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync6(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync17(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync6(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join20(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -40316,7 +40387,7 @@ function resolveAgentDiscovery(options) {
       const path = resolve13(root2, value);
       if (path !== root2 && !path.startsWith(root2 + sep3))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep3}SKILL.md`) ? dirname12(path) : path);
+      roots.add(path.endsWith(`${sep3}SKILL.md`) ? dirname13(path) : path);
     }
   }
   if (agent === "claude") {
@@ -40324,7 +40395,7 @@ function resolveAgentDiscovery(options) {
     const installed = registrations === null ? {} : parseConfig(registrations, join20(home, ".claude/plugins/installed_plugins.json")).plugins;
     const commands = canonical4(join20(home, ".claude/commands"));
     safe4(commands);
-    if (lstatSync16(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync6(commands).length)
+    if (lstatSync17(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync6(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id2, enabled] of Object.entries(config.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -40366,12 +40437,12 @@ function resolveAgentDiscovery(options) {
     }
     const localPlugins = join20(home, ".config/opencode/plugins");
     safe4(localPlugins);
-    if (lstatSync16(localPlugins, { throwIfNoEntry: false }) && readdirSync6(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync17(localPlugins, { throwIfNoEntry: false }) && readdirSync6(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "hermes") {
     for (const directory of [join20(home, ".hermes/plugins"), join20(home, ".hermes/hermes-agent")]) {
       safe4(directory);
-      if (lstatSync16(directory, { throwIfNoEntry: false }))
+      if (lstatSync17(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
     }
     if (Bun.which("hermes") || Object.keys(config.plugins ?? {}).length)
@@ -40381,11 +40452,11 @@ function resolveAgentDiscovery(options) {
       unresolved("custom extension or skill paths");
     const directory = join20(home, ".gemini/extensions");
     safe4(directory);
-    if (lstatSync16(directory, { throwIfNoEntry: false }))
+    if (lstatSync17(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync6(directory)) {
         const root2 = join20(directory, name);
         safe4(root2);
-        if (!lstatSync16(root2)?.isDirectory())
+        if (!lstatSync17(root2)?.isDirectory())
           continue;
         const raw = witness(join20(root2, "gemini-extension.json"));
         if (raw === null)
@@ -40540,7 +40611,7 @@ function disableCodexBundledSkills(text2) {
 }
 
 // src/lib/agent-integration.ts
-var sha = (data) => createHash14("sha256").update(data).digest("hex");
+var sha2 = (data) => createHash16("sha256").update(data).digest("hex");
 var ROOTS = [
   ["claude", ".claude/skills"],
   ["codex", ".codex/skills"],
@@ -40561,9 +40632,9 @@ var ROOTS = [
 function assertSafePath(path) {
   let cursor = resolve14(path);
   while (true) {
-    if (lstatSync17(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync18(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink path: ${cursor}`);
-    const parent = dirname13(cursor);
+    const parent = dirname14(cursor);
     if (parent === cursor)
       return;
     cursor = parent;
@@ -40572,12 +40643,12 @@ function assertSafePath(path) {
 function readRootAlias(home, agent) {
   assertSafePath(home);
   const realHome = realpathSync4(home), alias = join21(realHome, `.${agent}`);
-  const stat2 = lstatSync17(alias, { throwIfNoEntry: false, bigint: true });
+  const stat2 = lstatSync18(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat2?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link = readlinkSync2(alias), targetPath = resolve14(dirname13(alias), link);
+  const link = readlinkSync2(alias), targetPath = resolve14(dirname14(alias), link);
   assertSafePath(targetPath);
-  const targetStat = lstatSync17(targetPath, { throwIfNoEntry: false });
+  const targetStat = lstatSync18(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
   const target = realpathSync4(targetPath), inside = relative3(realHome, target);
@@ -40590,7 +40661,7 @@ function rootAliases(home, allowed = false) {
     return [];
   const result = [];
   for (const agent of ["claude", "codex"])
-    if (lstatSync17(join21(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync18(join21(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
       result.push(readRootAlias(home, agent));
   if (result.some((item, index) => result.slice(index + 1).some((other) => item.target === other.target || item.target.startsWith(other.target + sep4) || other.target.startsWith(item.target + sep4))))
     throw new Error("Agent root alias targets must not overlap");
@@ -40611,35 +40682,35 @@ function recheckRootAliases(aliases) {
 }
 function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   assertSafePath(path);
-  const before = lstatSync17(path);
+  const before = lstatSync18(path);
   if (!before.isFile() || before.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync15(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const descriptor = openSync16(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
-    const opened = fstatSync15(descriptor);
+    const opened = fstatSync16(descriptor);
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size)
       throw new Error("Native skill file changed while reading");
     const bytes = Buffer.allocUnsafe(before.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync10(descriptor, bytes, length, bytes.length - length, null);
+      const count = readSync11(descriptor, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after = fstatSync15(descriptor);
+    const after = fstatSync16(descriptor);
     if (length !== before.size || after.size !== before.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs)
       throw new Error("Native skill file changed while reading");
     return bytes.subarray(0, length);
   } finally {
-    closeSync15(descriptor);
+    closeSync16(descriptor);
   }
 }
 function treeHash(root2) {
-  const hash2 = createHash14("sha256");
+  const hash2 = createHash16("sha256");
   let bytes = 0, files = 0;
   function visit2(path) {
-    const stat2 = lstatSync17(path);
+    const stat2 = lstatSync18(path);
     if (stat2.isSymbolicLink())
       throw new Error(`Refusing symlink in skill: ${path}`);
     const rel = relative3(root2, path);
@@ -40669,7 +40740,7 @@ function selectNativeMigrationTargets(inventory, manifest) {
   const selected = [];
   for (const target of manifest.targets) {
     const projectRoot = resolve14(target.projectRoot), normalized = relative3(projectRoot, resolve14(projectRoot, target.path));
-    if (!isAbsolute15(target.projectRoot) || projectRoot !== target.projectRoot || !existsSync6(projectRoot) || !lstatSync17(projectRoot).isDirectory())
+    if (!isAbsolute15(target.projectRoot) || projectRoot !== target.projectRoot || !existsSync6(projectRoot) || !lstatSync18(projectRoot).isDirectory())
       throw new Error(`Native migration target project root must be an existing absolute directory: ${target.projectRoot}`);
     assertSafePath(projectRoot);
     if (isAbsolute15(target.path) || target.path.includes("\\") || target.path.includes("\x00") || !normalized || normalized === ".." || normalized.startsWith(`..${sep4}`) || normalized !== target.path || !/^[0-9a-f]{64}$/.test(target.treeSha256))
@@ -40698,7 +40769,7 @@ function projectAncestorDirectories(projects) {
       if (depth >= 100)
         throw new Error("NATIVE_SKILL_DRIFT: project ancestor discovery limit exceeded");
       directories.add(path);
-      const parent = dirname13(path);
+      const parent = dirname14(path);
       if (parent === path)
         break;
       path = parent;
@@ -40729,9 +40800,9 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
   }
   function emptySiblingCacheAlias(path, parent) {
     const link = readlinkSync2(path), target = resolve14(parent, link);
-    if (dirname13(target) !== parent || (isAbsolute15(link) ? link !== target : dirname13(link) !== "."))
+    if (dirname14(target) !== parent || (isAbsolute15(link) ? link !== target : dirname14(link) !== "."))
       return false;
-    if (!lstatSync17(target, { throwIfNoEntry: false })?.isDirectory())
+    if (!lstatSync18(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
     const scan = cacheScans.get(target);
     return Boolean(scan?.complete && !scan.hasSkills && scan.entries <= maxAliasProofEntries);
@@ -40743,7 +40814,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
     assertSafePath(path);
     if (!existsSync6(path))
       return scan;
-    const stat2 = lstatSync17(path);
+    const stat2 = lstatSync18(path);
     if (stat2.isFile())
       return scan;
     if (!stat2.isDirectory())
@@ -40789,7 +40860,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       if (isVendor && !options.includeVendor)
         continue;
       const child = join21(path, name);
-      if (isVendor && lstatSync17(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      if (isVendor && lstatSync18(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
         const target = statSync5(child, { throwIfNoEntry: false });
         if (target?.isFile() || pluginCache && target?.isDirectory() && emptySiblingCacheAlias(child, path)) {
           scan.entries++;
@@ -40999,7 +41070,7 @@ function planAgentIntegration(options) {
         throw new Error("Refusing to overwrite an unrecognized Hermes supervisor");
       if (supervisorBefore !== supervisorAfter)
         changes.push({ path: supervisorPath, before: supervisorBefore, after: supervisorAfter });
-      const supervisor = { path: supervisorPath, runtime: process.execPath, sha256: sha(supervisorAfter) };
+      const supervisor = { path: supervisorPath, runtime: process.execPath, sha256: sha2(supervisorAfter) };
       const after2 = configureHermesHooks(before, supervisor, previous);
       if (before !== after2)
         changes.push({ path, before, after: after2 });
@@ -41046,7 +41117,7 @@ function planAgentIntegration(options) {
     agents: [...new Set([...priorAgents, ...options.agents])].sort(),
     home: resolve14(home),
     includeVendor: true,
-    ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join21(dataDir2, "agent-hooks", "hermes.js"), runtime: process.execPath, sha256: sha(renderHermesSupervisor(bindings.get("hermes").command, bindings.get("hermes").profileId)) } } } : {},
+    ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join21(dataDir2, "agent-hooks", "hermes.js"), runtime: process.execPath, sha256: sha2(renderHermesSupervisor(bindings.get("hermes").command, bindings.get("hermes").profileId)) } } } : {},
     commands: { ...policy.bridge?.commands, ...Object.fromEntries([...bindings].map(([agent, binding]) => [agent, binding.command])) },
     profiles: Object.fromEntries([...new Set([...priorAgents, ...options.agents])].sort().map((agent) => [agent, bindings.get(agent)?.profileId ?? policy.bridge?.profiles?.[agent] ?? policy.profileId])),
     disabledBuiltins: options.agents.includes("codex") ? nativeSkills.filter((entry) => entry.agent === "codex" && entry.vendor && entry.path.startsWith(canonicalAgentPath(join21(home, ".codex", "skills", ".system"), aliases) + sep4)).map((entry) => ({ path: entry.path, hash: entry.hash })) : policy.bridge?.disabledBuiltins ?? [],
@@ -41061,10 +41132,10 @@ function planAgentIntegration(options) {
 }
 function atomicWrite2(path, content) {
   assertSafePath(path);
-  mkdirSync5(dirname13(path), { recursive: true, mode: 448 });
+  mkdirSync5(dirname14(path), { recursive: true, mode: 448 });
   const temporary = `${path}.skills-${randomUUID3()}`;
   try {
-    writeFileSync3(temporary, content, { mode: 384, flag: "wx" });
+    writeFileSync4(temporary, content, { mode: 384, flag: "wx" });
     renameSync3(temporary, path);
   } finally {
     if (existsSync6(temporary))
@@ -41098,8 +41169,8 @@ function applyAgentIntegration(plan) {
   chmodSync(backupRoot, 448);
   for (const [index, change] of plan.changes.entries())
     if (change.before !== null) {
-      const backup = join21(backupRoot, `${index}-${sha(change.path).slice(0, 12)}.backup`);
-      writeFileSync3(backup, change.before, { mode: 384, flag: "wx" });
+      const backup = join21(backupRoot, `${index}-${sha2(change.path).slice(0, 12)}.backup`);
+      writeFileSync4(backup, change.before, { mode: 384, flag: "wx" });
       backups.push(backup);
     }
   try {
@@ -41107,7 +41178,7 @@ function applyAgentIntegration(plan) {
       recheckRootAliases(aliases);
       if (currentText(change.path) !== change.before)
         throw new Error(`Configuration changed after planning: ${change.path}`);
-      for (let directory = dirname13(change.path);!existsSync6(directory); directory = dirname13(directory))
+      for (let directory = dirname14(change.path);!existsSync6(directory); directory = dirname14(directory))
         createdDirectories.add(directory);
       const after = change.after;
       atomicWrite2(change.path, after);
@@ -41116,7 +41187,7 @@ function applyAgentIntegration(plan) {
     recheckRootAliases(aliases);
     for (const binding of plan.discoveryAfter ?? [])
       verifyAgentDiscovery(binding);
-    atomicWrite2(join21(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha(change.before), afterHash: sha(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `
+    atomicWrite2(join21(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha2(change.before), afterHash: sha2(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `
 `);
   } catch (error) {
     for (const change of written.reverse()) {
@@ -41147,11 +41218,11 @@ function applyAgentIntegration(plan) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync15(path, constants11.O_RDONLY | constants11.O_DIRECTORY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+  const descriptor = openSync16(path, constants12.O_RDONLY | constants12.O_DIRECTORY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
   try {
-    fsyncSync3(descriptor);
+    fsyncSync4(descriptor);
   } finally {
-    closeSync15(descriptor);
+    closeSync16(descriptor);
   }
 }
 function writeArchiveJournal(path, value) {
@@ -41159,18 +41230,18 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID3()}`;
   let descriptor;
   try {
-    descriptor = openSync15(temporary, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
-    writeFileSync3(descriptor, `${JSON.stringify(value)}
+    descriptor = openSync16(temporary, constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+    writeFileSync4(descriptor, `${JSON.stringify(value)}
 `);
-    fsyncSync3(descriptor);
-    closeSync15(descriptor);
+    fsyncSync4(descriptor);
+    closeSync16(descriptor);
     descriptor = undefined;
     renameSync3(temporary, path);
-    syncArchiveDirectory(dirname13(path));
+    syncArchiveDirectory(dirname14(path));
   } finally {
     if (descriptor !== undefined)
-      closeSync15(descriptor);
-    if (lstatSync17(temporary, { throwIfNoEntry: false }))
+      closeSync16(descriptor);
+    if (lstatSync18(temporary, { throwIfNoEntry: false }))
       unlinkSync4(temporary);
   }
 }
@@ -41195,8 +41266,8 @@ function archiveNativeSkills(inventory, options) {
   const operationId = randomUUID3(), archiveRoot = join21(options.dataDir ?? getDataDir(), "migration", operationId, "native"), receiptPath = join21(archiveRoot, "receipt.json");
   const entries = selected.map((entry, index) => ({
     source: entry.vendor ? join21(entry.path, "SKILL.md") : entry.path,
-    archive: join21(archiveRoot, `${index}-${sha(entry.path).slice(0, 12)}`),
-    hash: entry.vendor ? sha(readNativeBytes(join21(entry.path, "SKILL.md"))) : entry.hash,
+    archive: join21(archiveRoot, `${index}-${sha2(entry.path).slice(0, 12)}`),
+    hash: entry.vendor ? sha2(readNativeBytes(join21(entry.path, "SKILL.md"))) : entry.hash,
     ...entry.vendor ? { discoveryOnly: true } : {},
     status: "planned"
   }));
@@ -41204,22 +41275,22 @@ function archiveNativeSkills(inventory, options) {
   const moved = [];
   const verifyArchive = (entry) => {
     assertSafePath(entry.archive);
-    const stat2 = lstatSync17(entry.archive);
+    const stat2 = lstatSync18(entry.archive);
     if (entry.discoveryOnly ? !stat2.isFile() : !stat2.isDirectory())
       throw new Error("Archive type changed");
-    if ((entry.discoveryOnly ? sha(readNativeBytes(entry.archive)) : treeHash(entry.archive)) !== entry.hash)
+    if ((entry.discoveryOnly ? sha2(readNativeBytes(entry.archive)) : treeHash(entry.archive)) !== entry.hash)
       throw new Error("Archive bytes changed");
   };
   assertSafePath(archiveRoot);
   const created = [];
-  for (let path = archiveRoot;!existsSync6(path); path = dirname13(path))
+  for (let path = archiveRoot;!existsSync6(path); path = dirname14(path))
     created.push(path);
   mkdirSync5(archiveRoot, { recursive: true, mode: 448 });
   try {
     for (const directory of created)
       syncArchiveDirectory(directory);
     if (created.length)
-      syncArchiveDirectory(dirname13(created.at(-1)));
+      syncArchiveDirectory(dirname14(created.at(-1)));
     writeArchiveJournal(receiptPath, journal);
     for (const [index, entry] of selected.entries()) {
       recheckRootAliases(aliases);
@@ -41231,7 +41302,7 @@ function archiveNativeSkills(inventory, options) {
       writeArchiveJournal(receiptPath, journal);
       renameSync3(move.source, move.archive);
       moved.push(move);
-      syncArchiveDirectory(dirname13(move.source));
+      syncArchiveDirectory(dirname14(move.source));
       syncArchiveDirectory(archiveRoot);
       verifyArchive(move);
       move.status = "archived";
@@ -41252,7 +41323,7 @@ function archiveNativeSkills(inventory, options) {
         recheckRootAliases(aliases);
         assertSafePath(entry.source);
         assertSafePath(entry.archive);
-        if (lstatSync17(entry.source, { throwIfNoEntry: false })) {
+        if (lstatSync18(entry.source, { throwIfNoEntry: false })) {
           entry.status = "recovery-required";
           entry.conflict = "source-occupied";
           continue;
@@ -41266,10 +41337,10 @@ function archiveNativeSkills(inventory, options) {
         }
         if (entry.discoveryOnly) {
           linkSync2(entry.archive, entry.source);
-          syncArchiveDirectory(dirname13(entry.source));
+          syncArchiveDirectory(dirname14(entry.source));
           unlinkSync4(entry.archive);
         } else {
-          if (lstatSync17(entry.source, { throwIfNoEntry: false })) {
+          if (lstatSync18(entry.source, { throwIfNoEntry: false })) {
             entry.status = "recovery-required";
             entry.conflict = "source-occupied";
             continue;
@@ -41277,7 +41348,7 @@ function archiveNativeSkills(inventory, options) {
           renameSync3(entry.archive, entry.source);
         }
         entry.status = "restored";
-        syncArchiveDirectory(dirname13(entry.source));
+        syncArchiveDirectory(dirname14(entry.source));
         syncArchiveDirectory(archiveRoot);
       } catch {
         entry.status = "recovery-required";
@@ -41311,15 +41382,15 @@ import {
   renameSync as renameSync4,
   rmSync as rmSync2,
   statSync as statSync8,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute16, join as join24, normalize as normalize2, relative as relative5, resolve as resolve15, sep as sep6 } from "path";
+import { basename as basename8, dirname as dirname16, isAbsolute as isAbsolute16, join as join24, normalize as normalize2, relative as relative5, resolve as resolve15, sep as sep6 } from "path";
 
 // src/lib/registry-data/index.ts
 var SKILLS = [];
 
 // src/lib/skill-hash.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { existsSync as existsSync7, readdirSync as readdirSync8, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
 import { join as join22, sep as sep5 } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
@@ -41443,13 +41514,13 @@ function* bundleHashParts(files) {
   yield new TextEncoder().encode("\x00");
 }
 function hashBundleFiles(files) {
-  const hash2 = createHash15(CONTENT_HASH_ALGORITHM);
+  const hash2 = createHash17(CONTENT_HASH_ALGORITHM);
   for (const part of bundleHashParts(files))
     hash2.update(part);
   return hash2.digest("hex");
 }
 async function hashBundleFilesCooperatively(files, check) {
-  const hash2 = createHash15(CONTENT_HASH_ALGORITHM);
+  const hash2 = createHash17(CONTENT_HASH_ALGORITHM);
   let bytesSinceYield = 0;
   for (const part of bundleHashParts(files)) {
     for (let offset = 0;offset < part.byteLength; offset += 64 * 1024) {
@@ -41532,7 +41603,7 @@ function snapshotContentEntries(entries, limits, check) {
     contentLimit("Content hash entry limit exceeded");
   if (Reflect.ownKeys(entries).length !== entries.length + 1)
     invalidContent("Invalid content hash entry array");
-  const snapshot = [];
+  const snapshot2 = [];
   const paths = new SkillEntryPaths;
   let rawBytes = 0;
   for (let index = 0;index < entries.length; index++) {
@@ -41556,10 +41627,10 @@ function snapshotContentEntries(entries, limits, check) {
     rawBytes += size;
     const bytes = new Uint8Array(new ArrayBuffer(size));
     bytes.set(entry.bytes);
-    snapshot.push({ path: entry.path, bytes, mode: entry.mode });
+    snapshot2.push({ path: entry.path, bytes, mode: entry.mode });
   }
   check();
-  return snapshot;
+  return snapshot2;
 }
 function coveredContentPath(path) {
   const segments = path.split("/");
@@ -41607,12 +41678,12 @@ async function hashContentEntries(entries, options) {
   try {
     signal?.addEventListener("abort", abort, { once: true });
     check();
-    const snapshot = snapshotContentEntries(entries, limits, check);
+    const snapshot2 = snapshotContentEntries(entries, limits, check);
     const normalized = [];
     let normalizedBytes = 0;
     let manifest;
     await new Promise((resolve15) => setImmediate(resolve15));
-    for (const entry of snapshot) {
+    for (const entry of snapshot2) {
       check();
       if (!coveredContentPath(entry.path))
         continue;
@@ -41832,13 +41903,13 @@ function validateRuntimeContract(manifest, issues, strict) {
 import {
   cpSync,
   existsSync as existsSync8,
-  lstatSync as lstatSync18,
+  lstatSync as lstatSync19,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync15,
   realpathSync as realpathSync5,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
-import { basename as basename7, dirname as dirname14, join as join23, relative as relative4 } from "path";
+import { basename as basename7, dirname as dirname15, join as join23, relative as relative4 } from "path";
 var ANY_SEGMENT_COPY_EXCLUDES = new Set([
   ".git",
   ".DS_Store",
@@ -41956,7 +42027,7 @@ function createInstructionManifest(name, options) {
 }
 function writeInstructionSkillTemplate(skillPath, manifest) {
   mkdirSync6(skillPath, { recursive: true });
-  writeFileSync4(join23(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
+  writeFileSync5(join23(skillPath, "SKILL.md"), renderInstructionSkillMd(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function renderInstructionSkillMd(manifest) {
@@ -42007,11 +42078,11 @@ function createPortableManifest(name, options) {
 }
 function writePortableSkillTemplate(skillPath, manifest) {
   mkdirSync6(join23(skillPath, "src"), { recursive: true });
-  writeFileSync4(join23(skillPath, "SKILL.md"), renderSkillMd(manifest));
-  writeFileSync4(join23(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
-  writeFileSync4(join23(skillPath, "package.json"), renderPackageJson(manifest));
-  writeFileSync4(join23(skillPath, "tsconfig.json"), renderTsconfig());
-  writeFileSync4(join23(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
+  writeFileSync5(join23(skillPath, "SKILL.md"), renderSkillMd(manifest));
+  writeFileSync5(join23(skillPath, "AGENTS.md"), renderAgentsMd(manifest));
+  writeFileSync5(join23(skillPath, "package.json"), renderPackageJson(manifest));
+  writeFileSync5(join23(skillPath, "tsconfig.json"), renderTsconfig());
+  writeFileSync5(join23(skillPath, "src", "index.ts"), renderEntrypoint(manifest));
   writeSkillJsonWithHash(skillPath, manifest);
 }
 function fillContractDefaults(manifest, entrypoint) {
@@ -42036,7 +42107,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: undefined
     }
   };
-  writeFileSync4(join23(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
+  writeFileSync5(join23(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withoutHash) }, null, 2)}
 `);
   const hash2 = computeContentHash(skillPath);
   const withHash = {
@@ -42046,7 +42117,7 @@ function writeSkillJsonWithHash(skillPath, manifest) {
       content_hash: hash2
     }
   };
-  writeFileSync4(join23(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
+  writeFileSync5(join23(skillPath, "skill.json"), `${JSON.stringify({ ...existing, ...renderSkillJsonObject(withHash) }, null, 2)}
 `);
   return withHash;
 }
@@ -42086,18 +42157,18 @@ function ensurePortableSkillFiles(skillPath, manifest) {
   };
   const entry = next.commands[0]?.entry ?? "src/index.ts";
   if (entry && !existsSync8(join23(skillPath, entry))) {
-    mkdirSync6(dirname14(join23(skillPath, entry)), { recursive: true });
-    writeFileSync4(join23(skillPath, entry), renderEntrypoint(next));
+    mkdirSync6(dirname15(join23(skillPath, entry)), { recursive: true });
+    writeFileSync5(join23(skillPath, entry), renderEntrypoint(next));
   }
   if (!existsSync8(join23(skillPath, "SKILL.md")))
-    writeFileSync4(join23(skillPath, "SKILL.md"), renderSkillMd(next));
+    writeFileSync5(join23(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync4(join23(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync15(join23(skillPath, "SKILL.md"), "utf-8"), next));
+    writeFileSync5(join23(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync15(join23(skillPath, "SKILL.md"), "utf-8"), next));
   if (!existsSync8(join23(skillPath, "AGENTS.md")))
-    writeFileSync4(join23(skillPath, "AGENTS.md"), renderAgentsMd(next));
+    writeFileSync5(join23(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
   if (!existsSync8(join23(skillPath, "tsconfig.json")))
-    writeFileSync4(join23(skillPath, "tsconfig.json"), renderTsconfig());
+    writeFileSync5(join23(skillPath, "tsconfig.json"), renderTsconfig());
   writeSkillJsonWithHash(skillPath, next);
   return readPortableSkillManifest(skillPath, next.name);
 }
@@ -42107,7 +42178,7 @@ function ensurePackageJson(skillPath, manifest) {
   const commandName = normalizePortableSkillName(first.name || manifest.name);
   const entry = (first.entry ?? "src/index.ts").replace(/^\.\//, "");
   if (!existsSync8(pkgPath)) {
-    writeFileSync4(pkgPath, renderPackageJson(manifest));
+    writeFileSync5(pkgPath, renderPackageJson(manifest));
     return;
   }
   const existing = readJsonObject(pkgPath);
@@ -42126,7 +42197,7 @@ function ensurePackageJson(skillPath, manifest) {
   const scripts = isRecord2(existing.scripts) ? { ...existing.scripts } : {};
   if (!stringValue(scripts.dev))
     scripts.dev = `bun run ${entry}`;
-  writeFileSync4(pkgPath, `${JSON.stringify({
+  writeFileSync5(pkgPath, `${JSON.stringify({
     ...existing,
     name: manifest.name,
     version: manifest.version,
@@ -42150,20 +42221,20 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     commands: []
   };
   if (!existsSync8(join23(skillPath, "SKILL.md"))) {
-    writeFileSync4(join23(skillPath, "SKILL.md"), renderSkillMd(next));
+    writeFileSync5(join23(skillPath, "SKILL.md"), renderSkillMd(next));
   } else {
     const path = join23(skillPath, "SKILL.md");
     const content = readFileSync15(path, "utf8");
     const declaredName = parseSkillFrontmatter(content)?.name;
     if (declaredName && declaredName !== next.name) {
-      writeFileSync4(path, renameInstructionFrontmatter(content, next.name));
+      writeFileSync5(path, renameInstructionFrontmatter(content, next.name));
     }
   }
   const packagePath = join23(skillPath, "package.json");
   if (existsSync8(packagePath)) {
     const pkg = readJsonObject(packagePath);
     if (typeof pkg.name === "string" && pkg.name !== next.name) {
-      writeFileSync4(packagePath, `${JSON.stringify({ ...pkg, name: next.name }, null, 2)}
+      writeFileSync5(packagePath, `${JSON.stringify({ ...pkg, name: next.name }, null, 2)}
 `);
     }
   }
@@ -42191,7 +42262,7 @@ function renameInstructionFrontmatter(content, name) {
   return renamed + content.slice(frontmatter[0].length);
 }
 function copySkillDirectory(source, destination) {
-  const resolvedSource = lstatSync18(source).isSymbolicLink() ? realpathSync5(source) : source;
+  const resolvedSource = lstatSync19(source).isSymbolicLink() ? realpathSync5(source) : source;
   mkdirSync6(destination, { recursive: true });
   cpSync(resolvedSource, destination, {
     recursive: true,
@@ -42204,7 +42275,7 @@ function copySkillDirectory(source, destination) {
         if (isExcludedCopyEntry(segments[i], i === 0))
           return false;
       }
-      if (lstatSync18(src).isSymbolicLink())
+      if (lstatSync19(src).isSymbolicLink())
         return false;
       return true;
     }
@@ -42625,7 +42696,7 @@ function physicalImportPath(path) {
   const suffix = [];
   while (!existsSync9(ancestor)) {
     suffix.unshift(basename8(ancestor));
-    ancestor = dirname15(ancestor);
+    ancestor = dirname16(ancestor);
   }
   return join24(realpathSync6(ancestor), ...suffix);
 }
@@ -42662,7 +42733,7 @@ function portPortableSkill(sourcePath, options = {}) {
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync2(destination, { recursive: true, force: true });
   }
-  mkdirSync7(dirname15(destination), { recursive: true });
+  mkdirSync7(dirname16(destination), { recursive: true });
   copySkillDirectory(absoluteSource, destination);
   const base = {
     ...inferred,
@@ -42702,7 +42773,7 @@ function writeCorpusSkill(input, options = {}) {
   const skillPath = join24(root2, name);
   const created = !existsSync9(skillPath);
   mkdirSync7(skillPath, { recursive: true });
-  writeFileSync5(join24(skillPath, "SKILL.md"), input.skillMd);
+  writeFileSync6(join24(skillPath, "SKILL.md"), input.skillMd);
   const manifest = buildCorpusManifest(input, name);
   writeSkillJsonWithHash(skillPath, manifest);
   return { name, path: skillPath, manifest, created };
@@ -42717,7 +42788,7 @@ function installCorpusSkillAtomically(input, options = {}) {
   let moved = false;
   let backup = null;
   try {
-    writeFileSync5(join24(staging, "SKILL.md"), input.skillMd);
+    writeFileSync6(join24(staging, "SKILL.md"), input.skillMd);
     const manifest = buildCorpusManifest(input, name);
     writeSkillJsonWithHash(staging, manifest);
     if (existsSync9(target)) {
@@ -42933,7 +43004,7 @@ function isSkillsOwnershipMarker(marker) {
 function hasSkillsOwnershipMarker(dir) {
   const path = join25(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync19(path).isFile())
+    if (!lstatSync20(path).isFile())
       return false;
     const marker = JSON.parse(readFileSync16(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
@@ -43159,7 +43230,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
-  const parentDir = dirname16(dir);
+  const parentDir = dirname17(dir);
   mkdirSync8(parentDir, { recursive: true });
   const transactionDir = mkdtempSync2(join25(parentDir, `.hasna-skills-write-${basename9(dir)}-`));
   const candidateDir = join25(transactionDir, "candidate");
@@ -43181,10 +43252,10 @@ function writeManagedSkillDir(dir, skillMd, options) {
     } else {
       mkdirSync8(candidateDir, { recursive: true });
     }
-    writeFileSync6(candidateSkillMdPath, skillMd.endsWith(`
+    writeFileSync7(candidateSkillMdPath, skillMd.endsWith(`
 `) ? skillMd : `${skillMd}
 `);
-    writeFileSync6(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
+    writeFileSync7(candidateMarkerPath, `${JSON.stringify(marker, null, 2)}
 `);
     if (dirExists) {
       originalMoved = true;
@@ -43572,7 +43643,7 @@ function getAllTags() {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
 import { join as join27 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
@@ -43621,7 +43692,7 @@ function saveProjectConfig(config, targetDir = process.cwd()) {
   const dir = getProjectStateDir(targetDir);
   mkdirSync9(dir, { recursive: true });
   const normalized = normalizeProjectConfig({ ...config, updatedAt: new Date().toISOString() });
-  writeFileSync7(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
+  writeFileSync8(getProjectConfigPath(targetDir), JSON.stringify(normalized, null, 2) + `
 `);
 }
 function pinProjectSkill(name, details = {}, targetDir = process.cwd()) {
@@ -44525,8 +44596,8 @@ async function executeSelectedLocal(selected, options = {}) {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
     const destination = join30(runDirectory, entry.path);
-    mkdirSync10(dirname17(destination), { recursive: true, mode: 448 });
-    writeFileSync8(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
+    mkdirSync10(dirname18(destination), { recursive: true, mode: 448 });
+    writeFileSync9(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
   env.SKILLS_INPUT_JSON = input;
   env.SKILLS_WORKSPACE_DIR = resolve16(options.cwd ?? process.cwd());
@@ -44559,13 +44630,13 @@ async function executeSelectedLocal(selected, options = {}) {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
-    inputDigest: `sha256:${createHash16("sha256").update(input).digest("hex")}`,
+    inputDigest: `sha256:${createHash18("sha256").update(input).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
     ...bindings ? { secretBinding: { schema: bindings.schema, selection: bindings.selection, consumer: bindings.consumer, secretsAuthority: bindings.secretsAuthority, bindings: bindings.bindings } } : {},
     ...result
   };
-  writeFileSync8(join30(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
+  writeFileSync9(join30(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
   return receipt;
 }
 async function subprocess(command, cwd, env, input, timeoutMs) {
@@ -53849,7 +53920,7 @@ var import_node_http_handler2 = __toESM(require_dist_cjs6(), 1);
 
 // node_modules/@aws-sdk/checksums/dist-cjs/submodules/sha/index.js
 var { toUint8Array: toUint8Array2, concatBytes } = require_serde();
-var { createHmac: createHmac2, createHash: createHash18 } = __require("crypto");
+var { createHmac: createHmac2, createHash: createHash20 } = __require("crypto");
 var { Sha256: Sha2562, Sha256Js, Sha256Node } = require_checksum();
 var BLOCK2 = 64;
 var DIGEST_LENGTH = 20;
@@ -54018,7 +54089,7 @@ class Sha1Js {
 }
 var hasNativeCrypto = (() => {
   try {
-    createHash18("sha1");
+    createHash20("sha1");
     return true;
   } catch {
     return false;
@@ -54058,7 +54129,7 @@ function buildNativeClass() {
       this.finished = false;
     }
     createHash() {
-      return this.secret ? createHmac2("sha1", toBuffer(this.secret)) : createHash18("sha1");
+      return this.secret ? createHmac2("sha1", toBuffer(this.secret)) : createHash20("sha1");
     }
   };
 }
@@ -54627,7 +54698,7 @@ function assertReservationCents(value, field2) {
 import { Database as Database2 } from "bun:sqlite";
 import { randomUUID as randomUUID8 } from "crypto";
 import { mkdirSync as mkdirSync12 } from "fs";
-import { dirname as dirname21 } from "path";
+import { dirname as dirname22 } from "path";
 
 // src/server/database-url.ts
 import { isAbsolute as isAbsolute17, join as join32 } from "path";
@@ -54923,12 +54994,12 @@ class PostgresSkillSelectionStore {
 // src/server/sqlite-store.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { mkdirSync as mkdirSync11, readFileSync as readFileSync22, readdirSync as readdirSync12 } from "fs";
-import { dirname as dirname20, join as join34 } from "path";
+import { dirname as dirname21, join as join34 } from "path";
 
 // src/server/auth.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 function hashApiKey(token) {
-  return createHash19("sha256").update(token).digest("hex");
+  return createHash21("sha256").update(token).digest("hex");
 }
 function bearerToken(request2) {
   const header = request2.headers.get("authorization") || "";
@@ -54982,7 +55053,7 @@ function permitsSkillsRoute(principal, method, resource) {
 
 // src/server/migrations-dir.ts
 import { existsSync as existsSync15 } from "fs";
-import { dirname as dirname19, join as join33 } from "path";
+import { dirname as dirname20, join as join33 } from "path";
 var MIGRATION_DIALECTS = ["postgres", "sqlite"];
 var MAX_WALK_UP = 6;
 function findMigrationsRoot(startDirs = defaultStartDirs()) {
@@ -54992,7 +55063,7 @@ function findMigrationsRoot(startDirs = defaultStartDirs()) {
       const candidate2 = join33(dir, "migrations");
       if (MIGRATION_DIALECTS.some((dialect) => existsSync15(join33(candidate2, dialect))))
         return candidate2;
-      const parent = dirname19(dir);
+      const parent = dirname20(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -55238,7 +55309,7 @@ function validOperatorScopeEnrollmentInput(input) {
 }
 
 // src/lib/revision.ts
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 var REVISION_ID_PATTERN = /^[0-9a-f]{64}$/;
 function revisionIdOf(content) {
   const canonicalContent = {
@@ -55260,7 +55331,7 @@ function revisionIdOf(content) {
     canonicalContent.replacementSlug = content.replacementSlug ?? null;
   }
   const canonical4 = JSON.stringify(canonicalContent);
-  return createHash20("sha256").update(canonical4).digest("hex");
+  return createHash22("sha256").update(canonical4).digest("hex");
 }
 function revisionIdOfRecord(record3) {
   return revisionIdOf(record3);
@@ -55285,7 +55356,7 @@ class SqliteSkillsStore {
   constructor(path = SQLITE_MEMORY_PATH, options = {}) {
     const inMemory = path === SQLITE_MEMORY_PATH;
     if (!inMemory)
-      mkdirSync11(dirname20(path), { recursive: true });
+      mkdirSync11(dirname21(path), { recursive: true });
     this.db = openDatabase(path);
     this.db.exec(`PRAGMA busy_timeout = ${Math.max(0, options.busyTimeoutMs ?? 5000)}`);
     if (!inMemory)
@@ -56095,7 +56166,7 @@ class SqliteGovernanceStore {
   closed = false;
   constructor(path = SQLITE_MEMORY_PATH, options = {}) {
     if (path !== SQLITE_MEMORY_PATH)
-      mkdirSync12(dirname21(path), { recursive: true });
+      mkdirSync12(dirname22(path), { recursive: true });
     this.db = new Database2(path, { create: true, readwrite: true });
     this.db.exec("PRAGMA busy_timeout = 5000");
     this.db.exec("PRAGMA foreign_keys = ON");
@@ -56328,7 +56399,7 @@ function nextMonthPrefix(monthPrefix) {
 }
 
 // src/server/skills-api.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 var SLUG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 var SHA256_HEX2 = /^[0-9a-f]{64}$/;
 var MAX_SLUG_LENGTH = 128;
@@ -56518,7 +56589,7 @@ async function parsePublishRequest(request2, config) {
     if (bundleBytes.byteLength === 0) {
       throw new SkillRequestError(400, "BUNDLE_EMPTY", "the uploaded bundle is empty");
     }
-    const sha2562 = createHash21("sha256").update(bundleBytes).digest("hex");
+    const sha2562 = createHash23("sha256").update(bundleBytes).digest("hex");
     const claimed = optionalString(manifest.bundleSha256);
     if (claimed)
       assertSha2562(claimed);
@@ -56633,7 +56704,7 @@ async function readPublishedBundle(store, artifactStorage, principal, slug) {
   if (!bytes) {
     throw new SkillRequestError(503, "BUNDLE_BACKEND_UNAVAILABLE", "bundle storage backend unavailable");
   }
-  const actual = createHash21("sha256").update(bytes).digest("hex");
+  const actual = createHash23("sha256").update(bytes).digest("hex");
   if (actual !== record3.bundleSha256) {
     throw new SkillRequestError(500, "BUNDLE_DIGEST_DRIFT", `stored bundle for '${slug}' hashes to ${actual} but was published as ${record3.bundleSha256}`);
   }
@@ -56781,7 +56852,7 @@ async function readSkillVersionBundle(store, artifactStorage, principal, slug, v
   const bytes = await artifactStorage.readBundle(bundle2);
   if (!bytes)
     throw new SkillRequestError(503, "BUNDLE_BACKEND_UNAVAILABLE", "bundle storage backend unavailable");
-  const actual = createHash21("sha256").update(bytes).digest("hex");
+  const actual = createHash23("sha256").update(bytes).digest("hex");
   if (actual !== found.bundleSha256) {
     throw new SkillRequestError(500, "BUNDLE_DIGEST_DRIFT", `stored bundle for '${slug}@${version2}' hashes to ${actual} but was published as ${found.bundleSha256}`);
   }
@@ -57183,7 +57254,7 @@ async function handleProfileApi(store, principal, request2, parts, config) {
 // src/server/runtime-store.ts
 import { Database as Database3 } from "bun:sqlite";
 import { mkdirSync as mkdirSync13 } from "fs";
-import { dirname as dirname22 } from "path";
+import { dirname as dirname23 } from "path";
 
 // src/sdk/execution/types.ts
 var EXECUTION_PROTOCOL_VERSION = REMOTE_SKILL_RUN_CONTRACT_VERSION;
@@ -57239,7 +57310,7 @@ class RuntimeExecutionStore {
     }
     const path = target.kind === "sqlite" ? target.path : ":memory:";
     if (path !== ":memory:")
-      mkdirSync13(dirname22(path), { recursive: true });
+      mkdirSync13(dirname23(path), { recursive: true });
     const db = new Database3(path);
     db.run("PRAGMA busy_timeout=5000");
     db.run("PRAGMA journal_mode=WAL");
@@ -57479,7 +57550,7 @@ class RuntimeExecutionStore {
 }
 
 // src/sdk/execution/admission.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 
 // src/sdk/execution/image-profile.ts
 class ImageProfileResolutionError extends Error {
@@ -58091,11 +58162,11 @@ function ownedAdmission(admission) {
   };
 }
 function digestInput(input) {
-  return createHash23("sha256").update(canonicalJson2(input)).digest("hex");
+  return createHash25("sha256").update(canonicalJson2(input)).digest("hex");
 }
 
 // src/sdk/execution/dispatchers/ecs.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 
 // src/sdk/execution/state-machine.ts
 var LEGAL_TRANSITIONS = {
@@ -61495,13 +61566,13 @@ function observedTask(states, taskArn) {
   return state2.lastStatus === "STOPPED" || LIVE_TASK_STATUSES.has(state2.lastStatus) ? state2 : undefined;
 }
 function clientTokenFor(runId3, attemptId) {
-  return createHash24("sha256").update(`${runId3}\x00${attemptId}`).digest("hex").slice(0, CLIENT_TOKEN_BYTES * 2);
+  return createHash26("sha256").update(`${runId3}\x00${attemptId}`).digest("hex").slice(0, CLIENT_TOKEN_BYTES * 2);
 }
 function startedByFor(runId3, attemptNumber) {
   return `skills-exec/${runId3}/a${attemptNumber}`;
 }
 function requestDigestFor(admission, attemptId) {
-  return createHash24("sha256").update(canonicalJson2({ admission, attemptId })).digest("hex");
+  return createHash26("sha256").update(canonicalJson2({ admission, attemptId })).digest("hex");
 }
 
 class EcsDispatcher {
@@ -61797,10 +61868,10 @@ function validText(value) {
 }
 
 // src/server/runtime-policy.ts
-import { createHash as createHash26, createHmac as createHmac3, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHash as createHash28, createHmac as createHmac3, timingSafeEqual as timingSafeEqual2 } from "crypto";
 
 // src/server/runtime-pure-contract.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 var PURE_DESCRIPTOR = Object.freeze({
   id: "regex-test.v1",
   runtime: "bun",
@@ -61824,7 +61895,7 @@ var PURE_LIMITS = Object.freeze({
   maxArtifactsBytes: 0,
   maxConcurrency: 1
 });
-var hash2 = (bytes) => createHash25("sha256").update(bytes).digest("hex");
+var hash2 = (bytes) => createHash27("sha256").update(bytes).digest("hex");
 var object5 = (v2) => {
   if (!v2 || typeof v2 !== "object" || Array.isArray(v2))
     throw Error("Pure contract requires an object");
@@ -62053,7 +62124,7 @@ function verifyRuntimeToken(token, key, admission, attempt, now = Date.now()) {
   const actual = Buffer.from(token);
   return actual.length === expected.length && timingSafeEqual2(actual, expected);
 }
-var hashBytes = (bytes) => createHash26("sha256").update(bytes).digest("hex");
+var hashBytes = (bytes) => createHash28("sha256").update(bytes).digest("hex");
 
 // src/server/runtime-api.ts
 async function createRuntimeService(options) {
@@ -68386,7 +68457,7 @@ var localRunExecutor = {
 // src/sdk/storage.ts
 var artifactStorageSeam = ArtifactStorage;
 // src/sdk/outputs.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 class DatabaseOnlyObjectStore {
   usesS3 = false;
   async materialize(run, artifact, body4) {
@@ -68433,7 +68504,7 @@ function createGovernedArtifactWriter(options) {
       const stamped = {
         ...meta,
         byteSize: outputBytes,
-        sha256: createHash27("sha256").update(persistedBytes).digest("hex"),
+        sha256: createHash29("sha256").update(persistedBytes).digest("hex"),
         visibility: options.visibility ?? config.defaultVisibility,
         ...config.artifactTtlSeconds !== undefined ? { expiresAt: expiresAtFor(createdAt, config.artifactTtlSeconds) } : {}
       };
@@ -87200,7 +87271,7 @@ function date4(params) {
   return _coercedDate(ZodDate2, params);
 }
 // src/lib/canonical-json.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 function canonicalJson3(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -87244,7 +87315,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash28("sha256").update(canonicalJson3(value, maximumBytes)).digest("hex");
+  return createHash30("sha256").update(canonicalJson3(value, maximumBytes)).digest("hex");
 }
 
 // src/lib/remote-recurring-contract.ts
@@ -87387,8 +87458,8 @@ var inputs = {
 };
 function recurringInput(action, raw) {
   try {
-    const snapshot = JSON.parse(canonicalJson3(raw, action === "preview" ? 1048576 : 4096));
-    return inputs[action].parse(snapshot);
+    const snapshot2 = JSON.parse(canonicalJson3(raw, action === "preview" ? 1048576 : 4096));
+    return inputs[action].parse(snapshot2);
   } catch {
     throw new RecurringInputError;
   }
@@ -89345,7 +89416,7 @@ async function requestInvitationEmail(origin, action, input2) {
 }
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash31 } from "crypto";
 var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
 var failures2 = {
   INVALID_REQUEST: [400, "The publication request is invalid."],
@@ -89392,7 +89463,7 @@ var hash4 = (v2) => typeof v2 === "string" && /^[a-f0-9]{64}$/.test(v2);
 var record9 = (v2) => !!v2 && typeof v2 === "object" && !Array.isArray(v2);
 var exact = (v2, keys3) => record9(v2) && Object.keys(v2).sort().join(",") === keys3.sort().join(",");
 var date5 = (v2) => typeof v2 === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v2) && Number.isFinite(Date.parse(v2));
-var publicationSha256 = (bytes) => createHash29("sha256").update(bytes).digest("hex");
+var publicationSha256 = (bytes) => createHash31("sha256").update(bytes).digest("hex");
 function checkedPublicationDeclaration(value) {
   if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash4(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -89874,8 +89945,8 @@ class RemoteSkillsAuthClient {
   }
 }
 // src/lib/private-publication-recovery.ts
-import { constants as constants12, closeSync as closeSync16, fsyncSync as fsyncSync4, fstatSync as fstatSync16, lstatSync as lstatSync20, mkdirSync as mkdirSync14, openSync as openSync16, readSync as readSync11, realpathSync as realpathSync8, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname23, isAbsolute as isAbsolute18, join as join36, resolve as resolve18 } from "path";
+import { constants as constants13, closeSync as closeSync17, fsyncSync as fsyncSync5, fstatSync as fstatSync17, lstatSync as lstatSync21, mkdirSync as mkdirSync14, openSync as openSync17, readSync as readSync12, realpathSync as realpathSync8, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname24, isAbsolute as isAbsolute18, join as join36, resolve as resolve18 } from "path";
 import { randomUUID as randomUUID11 } from "crypto";
 var fail = () => {
   throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
@@ -89883,14 +89954,14 @@ var fail = () => {
 function safeDirectory(directory) {
   if (!isAbsolute18(directory) || directory !== resolve18(directory) || realpathSync8(directory) !== directory)
     return fail();
-  for (let path2 = directory;; path2 = dirname23(path2)) {
-    const stat2 = lstatSync20(path2);
+  for (let path2 = directory;; path2 = dirname24(path2)) {
+    const stat2 = lstatSync21(path2);
     if (!stat2.isDirectory() || stat2.isSymbolicLink())
       return fail();
-    if (path2 === dirname23(path2))
+    if (path2 === dirname24(path2))
       break;
   }
-  const own2 = lstatSync20(directory);
+  const own2 = lstatSync21(directory);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
     return fail();
   return { dev: own2.dev, ino: own2.ino };
@@ -89902,35 +89973,35 @@ function unchangedDirectory(directory, identity3) {
 }
 function readOwned(directory, name, max) {
   const identity3 = safeDirectory(directory), file2 = join36(directory, name);
-  const fd = openSync16(file2, constants12.O_RDONLY | constants12.O_NOFOLLOW);
+  const fd = openSync17(file2, constants13.O_RDONLY | constants13.O_NOFOLLOW);
   try {
-    const stat2 = fstatSync16(fd);
+    const stat2 = fstatSync17(fd);
     if (!stat2.isFile() || stat2.nlink !== 1 || stat2.size > max || stat2.size < 1 || (stat2.mode & 63) !== 0 || process.getuid && stat2.uid !== process.getuid())
       return fail();
     const buffer = Buffer.alloc(Math.min(max, stat2.size) + 1);
     let length = 0;
     while (length < buffer.length) {
-      const count = readSync11(fd, buffer, length, buffer.length - length, length);
+      const count = readSync12(fd, buffer, length, buffer.length - length, length);
       if (count === 0)
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after = fstatSync16(fd);
+    const bytes = buffer.subarray(0, length), after = fstatSync17(fd);
     unchangedDirectory(directory, identity3);
     if (bytes.length !== stat2.size || stat2.size !== after.size || stat2.mtimeMs !== after.mtimeMs || stat2.ctimeMs !== after.ctimeMs)
       return fail();
     return bytes;
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function writeOwned(directory, name, bytes) {
-  const fd = openSync16(join36(directory, name), constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+  const fd = openSync17(join36(directory, name), constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL | constants13.O_NOFOLLOW, 384);
   try {
-    writeFileSync9(fd, bytes);
-    fsyncSync4(fd);
+    writeFileSync10(fd, bytes);
+    fsyncSync5(fd);
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function save(directory, value) {
@@ -89939,11 +90010,11 @@ function save(directory, value) {
 `);
   unchangedDirectory(directory, identity3);
   renameSync6(join36(directory, temporary), join36(directory, "receipt.json"));
-  const fd = openSync16(directory, constants12.O_RDONLY | constants12.O_NOFOLLOW);
+  const fd = openSync17(directory, constants13.O_RDONLY | constants13.O_NOFOLLOW);
   try {
-    fsyncSync4(fd);
+    fsyncSync5(fd);
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function bind(client2, receipt) {
@@ -89954,20 +90025,20 @@ async function locked(directory, action) {
   const identity3 = safeDirectory(directory), file2 = join36(directory, "operation.lock");
   let fd;
   try {
-    fd = openSync16(file2, constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+    fd = openSync17(file2, constants13.O_WRONLY | constants13.O_CREAT | constants13.O_EXCL | constants13.O_NOFOLLOW, 384);
   } catch {
     throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
   }
-  const lock = fstatSync16(fd);
+  const lock = fstatSync17(fd);
   try {
-    writeFileSync9(fd, JSON.stringify({ pid: process.pid }) + `
+    writeFileSync10(fd, JSON.stringify({ pid: process.pid }) + `
 `);
-    fsyncSync4(fd);
+    fsyncSync5(fd);
     return await action();
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
     unchangedDirectory(directory, identity3);
-    const now2 = lstatSync20(file2);
+    const now2 = lstatSync21(file2);
     if (now2.dev !== lock.dev || now2.ino !== lock.ino || !now2.isFile() || now2.isSymbolicLink())
       fail();
     unlinkSync5(file2);
@@ -90019,15 +90090,15 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute18(recoveryDirectory) || resolve18(recoveryDirectory) !== recoveryDirectory || realpathSync8(dirname23(recoveryDirectory)) !== dirname23(recoveryDirectory))
+  if (!isAbsolute18(recoveryDirectory) || resolve18(recoveryDirectory) !== recoveryDirectory || realpathSync8(dirname24(recoveryDirectory)) !== dirname24(recoveryDirectory))
     return fail();
   mkdirSync14(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync16(dirname23(recoveryDirectory), constants12.O_RDONLY | constants12.O_NOFOLLOW);
+  const parent = openSync17(dirname24(recoveryDirectory), constants13.O_RDONLY | constants13.O_NOFOLLOW);
   try {
-    fsyncSync4(parent);
+    fsyncSync5(parent);
   } finally {
-    closeSync16(parent);
+    closeSync17(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
   save(recoveryDirectory, receipt);
@@ -90135,7 +90206,7 @@ function exact2(value, names) {
   const keys3 = Object.keys(value).sort(), expected = [...names].sort();
   return keys3.length === expected.length && keys3.every((key, index) => key === expected[index]);
 }
-function snapshot(value, maximum) {
+function snapshot2(value, maximum) {
   let nodes4 = 0, bytes = 0;
   const parts = [], ancestors2 = new Set;
   const append = (part) => {
@@ -90214,7 +90285,7 @@ function snapshot(value, maximum) {
 }
 function requestSnapshot(input2) {
   try {
-    const owned = snapshot(input2, SKILL_OPERATION_LIMITS.requestBytes), value = owned.value;
+    const owned = snapshot2(input2, SKILL_OPERATION_LIMITS.requestBytes), value = owned.value;
     if (!record10(value) || !exact2(value, ["contractVersion", "requestId", "operation", "input"]) || value.contractVersion !== 1 || !validId(value.requestId) || typeof value.operation !== "string" || value.operation.length > 128 || !/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(value.operation) || !record10(value.input))
       throw Error();
     return { ...owned, value };
@@ -90224,7 +90295,7 @@ function requestSnapshot(input2) {
 }
 function resultSnapshot(input2, requestId) {
   try {
-    const value = snapshot(input2, SKILL_OPERATION_LIMITS.resultBytes).value;
+    const value = snapshot2(input2, SKILL_OPERATION_LIMITS.resultBytes).value;
     if (!record10(value) || value.contractVersion !== 1 || value.requestId !== requestId)
       throw Error();
     const fields = ["contractVersion", "requestId", "status"];