@hasna/skills 0.10.1 → 0.10.3

package/dist/sdk/index.js

@@ -7173,9 +7173,9 @@ var require_transport = __commonJS((exports) => {
     }
     return true;
   };
-  function isValidHostname(hostname) {
+  function isValidHostname(hostname2) {
     const hostPattern = /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/;
-    return hostPattern.test(hostname);
+    return hostPattern.test(hostname2);
   }
   var normalizeProvider = (input) => {
     if (typeof input === "function")
@@ -7208,13 +7208,13 @@ var require_transport = __commonJS((exports) => {
     if (typeof url === "string") {
       return parseUrl(new URL(url));
     }
-    const { hostname, pathname, port, protocol, search } = url;
+    const { hostname: hostname2, pathname, port, protocol, search } = url;
     let query;
     if (search) {
       query = parseQueryString(search);
     }
     return {
-      hostname,
+      hostname: hostname2,
       port: port ? parseInt(port) : undefined,
       protocol,
       path: pathname,
@@ -9399,11 +9399,11 @@ var require_config = __commonJS((exports) => {
     }
     const useDualstackEndpoint = await input.useDualstackEndpoint();
     const useFipsEndpoint = await input.useFipsEndpoint();
-    const { hostname } = await input.regionInfoProvider(region, { useDualstackEndpoint, useFipsEndpoint }) ?? {};
-    if (!hostname) {
+    const { hostname: hostname2 } = await input.regionInfoProvider(region, { useDualstackEndpoint, useFipsEndpoint }) ?? {};
+    if (!hostname2) {
       throw new Error("Cannot resolve hostname from client config");
     }
-    return input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`);
+    return input.urlParser(`${tls ? "https:" : "http:"}//${hostname2}`);
   };
   var resolveEndpointsConfig = (input) => {
     const useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint ?? false);
@@ -9566,12 +9566,12 @@ var require_config = __commonJS((exports) => {
   var getHostnameFromVariants = (variants = [], { useFipsEndpoint, useDualstackEndpoint }) => variants.find(({ tags }) => useFipsEndpoint === tags.includes("fips") && useDualstackEndpoint === tags.includes("dualstack"))?.hostname;
   var getResolvedHostname = (resolvedRegion, { regionHostname, partitionHostname }) => regionHostname ? regionHostname : partitionHostname ? partitionHostname.replace("{region}", resolvedRegion) : undefined;
   var getResolvedPartition = (region, { partitionHash }) => Object.keys(partitionHash || {}).find((key) => partitionHash[key].regions.includes(region)) ?? "aws";
-  var getResolvedSigningRegion = (hostname, { signingRegion, regionRegex, useFipsEndpoint }) => {
+  var getResolvedSigningRegion = (hostname2, { signingRegion, regionRegex, useFipsEndpoint }) => {
     if (signingRegion) {
       return signingRegion;
     } else if (useFipsEndpoint) {
       const regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\.");
-      const regionRegexmatchArray = hostname.match(regionRegexJs);
+      const regionRegexmatchArray = hostname2.match(regionRegexJs);
       if (regionRegexmatchArray) {
         return regionRegexmatchArray[0].slice(1, -1);
       }
@@ -9583,11 +9583,11 @@ var require_config = __commonJS((exports) => {
     const hostnameOptions = { useFipsEndpoint, useDualstackEndpoint };
     const regionHostname = getHostnameFromVariants(regionHash[resolvedRegion]?.variants, hostnameOptions);
     const partitionHostname = getHostnameFromVariants(partitionHash[partition]?.variants, hostnameOptions);
-    const hostname = getResolvedHostname(resolvedRegion, { regionHostname, partitionHostname });
-    if (hostname === undefined) {
+    const hostname2 = getResolvedHostname(resolvedRegion, { regionHostname, partitionHostname });
+    if (hostname2 === undefined) {
       throw new Error(`Endpoint resolution failed for: ${{ resolvedRegion, useFipsEndpoint, useDualstackEndpoint }}`);
     }
-    const signingRegion = getResolvedSigningRegion(hostname, {
+    const signingRegion = getResolvedSigningRegion(hostname2, {
       signingRegion: regionHash[resolvedRegion]?.signingRegion,
       regionRegex: partitionHash[partition].regionRegex,
       useFipsEndpoint
@@ -9595,7 +9595,7 @@ var require_config = __commonJS((exports) => {
     return {
       partition,
       signingService,
-      hostname,
+      hostname: hostname2,
       ...signingRegion && { signingRegion },
       ...regionHash[resolvedRegion]?.signingService && {
         signingService: regionHash[resolvedRegion].signingService
@@ -9820,8 +9820,8 @@ var require_endpoints = __commonJS((exports) => {
             return endpoint.url.href;
           }
           if ("hostname" in endpoint) {
-            const { protocol, hostname, port, path } = endpoint;
-            return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
+            const { protocol, hostname: hostname2, port, path } = endpoint;
+            return `${protocol}//${hostname2}${port ? ":" + port : ""}${path}`;
           }
         }
         return endpoint;
@@ -10128,8 +10128,8 @@ var require_endpoints = __commonJS((exports) => {
           return value;
         }
         if (typeof value === "object" && "hostname" in value) {
-          const { hostname: hostname2, port, protocol: protocol2 = "", path = "", query = {} } = value;
-          const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path}`);
+          const { hostname: hostname3, port, protocol: protocol2 = "", path = "", query = {} } = value;
+          const url = new URL(`${protocol2}//${hostname3}${port ? `:${port}` : ""}${path}`);
           url.search = Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&");
           return url;
         }
@@ -10143,7 +10143,7 @@ var require_endpoints = __commonJS((exports) => {
       return null;
     }
     const urlString = whatwgURL.href;
-    const { host, hostname, pathname, protocol, search } = whatwgURL;
+    const { host, hostname: hostname2, pathname, protocol, search } = whatwgURL;
     if (search) {
       return null;
     }
@@ -10151,7 +10151,7 @@ var require_endpoints = __commonJS((exports) => {
     if (!Object.values(EndpointURLScheme).includes(scheme)) {
       return null;
     }
-    const isIp = isIpAddress(hostname);
+    const isIp = isIpAddress(hostname2);
     const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) || typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`);
     const authority2 = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
     return {
@@ -14232,14 +14232,14 @@ var require_protocols = __commonJS((exports) => {
       this.context = context;
     }
     async build() {
-      const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
+      const { hostname: hostname2, protocol = "https", port, path: basePath } = await this.context.endpoint();
       this.path = basePath;
       for (const resolvePath of this.resolvePathStack) {
         resolvePath(this.path);
       }
       return new HttpRequest({
         protocol,
-        hostname: this.hostname || hostname,
+        hostname: this.hostname || hostname2,
         port,
         method: this.method,
         path: this.path,
@@ -14248,8 +14248,8 @@ var require_protocols = __commonJS((exports) => {
         headers: this.headers
       });
     }
-    hn(hostname) {
-      this.hostname = hostname;
+    hn(hostname2) {
+      this.hostname = hostname2;
       return this;
     }
     bp(uriLabel) {
@@ -18564,12 +18564,12 @@ var require_util = __commonJS((exports) => {
   };
   function formatUrl(request2) {
     const { port, query } = request2;
-    let { protocol, path, hostname } = request2;
+    let { protocol, path, hostname: hostname2 } = request2;
     if (protocol && protocol.slice(-1) !== ":") {
       protocol += ":";
     }
     if (port) {
-      hostname += `:${port}`;
+      hostname2 += `:${port}`;
     }
     if (path && path.charAt(0) !== "/") {
       path = `/${path}`;
@@ -18588,7 +18588,7 @@ var require_util = __commonJS((exports) => {
     if (request2.fragment) {
       fragment = `#${request2.fragment}`;
     }
-    return `${protocol}//${auth}${hostname}${path}${queryString}${fragment}`;
+    return `${protocol}//${auth}${hostname2}${path}${queryString}${fragment}`;
   }
   exports.build = build;
   exports.formatUrl = formatUrl;
@@ -19477,10 +19477,10 @@ var require_cbor = __commonJS((exports) => {
   };
   var buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
     const endpoint = await context.endpoint();
-    const { hostname, protocol = "https", port, path: basePath } = endpoint;
+    const { hostname: hostname2, protocol = "https", port, path: basePath } = endpoint;
     const contents = {
       protocol,
-      hostname,
+      hostname: hostname2,
       port,
       method: "POST",
       path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
@@ -25338,15 +25338,15 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         if (request2.fragment) {
           path += `#${request2.fragment}`;
         }
-        let hostname = request2.hostname ?? "";
-        if (hostname[0] === "[" && hostname.endsWith("]")) {
-          hostname = request2.hostname.slice(1, -1);
+        let hostname2 = request2.hostname ?? "";
+        if (hostname2[0] === "[" && hostname2.endsWith("]")) {
+          hostname2 = request2.hostname.slice(1, -1);
         } else {
-          hostname = request2.hostname;
+          hostname2 = request2.hostname;
         }
         const nodeHttpsOptions = {
           headers: request2.headers,
-          host: hostname,
+          host: hostname2,
           method: request2.method,
           path,
           port: request2.port,
@@ -25738,14 +25738,14 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
           reject(abortError);
           return;
         }
-        const { hostname, method, port, protocol, query } = request2;
+        const { hostname: hostname2, method, port, protocol, query } = request2;
         let auth = "";
         if (request2.username != null || request2.password != null) {
           const username = request2.username ?? "";
           const password = request2.password ?? "";
           auth = `${username}:${password}@`;
         }
-        const authority2 = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
+        const authority2 = `${protocol}//${auth}${hostname2}${port ? `:${port}` : ""}`;
         const requestContext = { destination: new URL(authority2) };
         const connectConfig = {
           requestTimeout: this.config?.sessionTimeout,
@@ -30946,7 +30946,7 @@ var fromWebToken = (init) => async (awsIdentityProperties) => {
 };
 
 // node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 var import_client19, import_config32, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE", ENV_ROLE_ARN = "AWS_ROLE_ARN", ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME", fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
   init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
   const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
@@ -30959,7 +30959,7 @@ var import_client19, import_config32, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_F
   }
   const credentials = await fromWebToken({
     ...init,
-    webIdentityToken: import_config32.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync21(webIdentityTokenFile, { encoding: "ascii" }),
+    webIdentityToken: import_config32.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync22(webIdentityTokenFile, { encoding: "ascii" }),
     roleArn,
     roleSessionName
   })(awsIdentityProperties);
@@ -31530,42 +31530,42 @@ function isPrivateAddress(address) {
   return true;
 }
 async function resolveWebhookTarget(url, policy = {}) {
-  const hostname = normalizeHostname(url.hostname);
+  const hostname2 = normalizeHostname(url.hostname);
   const allowlist = (policy.allowPrivateHosts ?? []).map((entry) => normalizeHostname(entry.toLowerCase()));
-  if (allowlist.includes(hostname)) {
-    const version22 = isIP3(hostname);
+  if (allowlist.includes(hostname2)) {
+    const version22 = isIP3(hostname2);
     if (version22 === 4 || version22 === 6) {
-      return { hostname, addresses: [hostname] };
+      return { hostname: hostname2, addresses: [hostname2] };
     }
     const lookup2 = policy.lookup ?? defaultTargetLookup;
     let resolved2;
     try {
-      resolved2 = await lookup2(hostname);
+      resolved2 = await lookup2(hostname2);
     } catch {
-      throw new Error(`Webhook target ${hostname} could not be resolved`);
+      throw new Error(`Webhook target ${hostname2} could not be resolved`);
     }
     if (!Array.isArray(resolved2) || resolved2.length === 0) {
-      throw new Error(`Webhook target ${hostname} resolved to no addresses`);
+      throw new Error(`Webhook target ${hostname2} resolved to no addresses`);
     }
     const addresses = resolved2.map((entry) => normalizeHostname(entry.address));
-    return { hostname, addresses };
+    return { hostname: hostname2, addresses };
   }
-  const version2 = isIP3(hostname);
+  const version2 = isIP3(hostname2);
   if (version2 === 4 || version2 === 6) {
-    if (isPrivateAddress(hostname)) {
-      throw new Error(`Webhook target ${hostname} is a private or special-use address`);
+    if (isPrivateAddress(hostname2)) {
+      throw new Error(`Webhook target ${hostname2} is a private or special-use address`);
     }
-    return { hostname, addresses: [hostname] };
+    return { hostname: hostname2, addresses: [hostname2] };
   }
   const lookup = policy.lookup ?? defaultTargetLookup;
   let resolved;
   try {
-    resolved = await lookup(hostname);
+    resolved = await lookup(hostname2);
   } catch {
-    throw new Error(`Webhook target ${hostname} could not be resolved`);
+    throw new Error(`Webhook target ${hostname2} could not be resolved`);
   }
   if (!Array.isArray(resolved) || resolved.length === 0) {
-    throw new Error(`Webhook target ${hostname} resolved to no addresses`);
+    throw new Error(`Webhook target ${hostname2} resolved to no addresses`);
   }
   const allowed = [];
   for (const entry of resolved) {
@@ -31575,14 +31575,14 @@ async function resolveWebhookTarget(url, policy = {}) {
         allowed.push(address);
         continue;
       }
-      throw new Error(`Webhook target ${hostname} resolves to private or special-use address ${address}`);
+      throw new Error(`Webhook target ${hostname2} resolves to private or special-use address ${address}`);
     }
     allowed.push(address);
   }
   if (allowed.length === 0) {
-    throw new Error(`Webhook target ${hostname} resolved to no public addresses`);
+    throw new Error(`Webhook target ${hostname2} resolved to no public addresses`);
   }
-  return { hostname, addresses: allowed };
+  return { hostname: hostname2, addresses: allowed };
 }
 function normalizeMaxRedirects(value) {
   if (value === undefined)
@@ -31591,8 +31591,8 @@ function normalizeMaxRedirects(value) {
     throw new Error("webhookTargetPolicy.maxRedirects must be a non-negative integer");
   return value;
 }
-function normalizeHostname(hostname) {
-  const lower = hostname.toLowerCase();
+function normalizeHostname(hostname2) {
+  const lower = hostname2.toLowerCase();
   if (lower.startsWith("[") && lower.endsWith("]"))
     return lower.slice(1, -1);
   return lower;
@@ -31785,7 +31785,7 @@ async function pinnedNativeRequest(target, addresses, method, headers, body4, si
     method,
     headers,
     ...tls?.ca ? { ca: tls.ca } : {},
-    lookup: (hostname, _options, callback) => {
+    lookup: (hostname2, _options, callback) => {
       const entries = addresses.map((address) => ({
         address,
         family: address.includes(":") ? 6 : 4
@@ -32291,8 +32291,8 @@ function normalizeRetryPolicy(policy) {
     multiplier: Math.max(1, policy?.multiplier ?? 2)
   };
 }
-var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE3, HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR", HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME", EVENTS_STORE_SENTINEL_FILE = "events.json", LOCAL_JSON_EVENT_CURSOR_PREFIX = "local-json-v1:", DEFAULT_EVENT_PAGE_LIMIT = 100, MAX_EVENT_PAGE_LIMIT = 1000, DEFAULT_SIGNATURE_TOLERANCE_MS, DEFAULT_MAX_REDIRECTS = 5, IPV4_PRIVATE_RANGES, IPV6_SPECIAL_PREFIXES, defaultTargetLookup = async (hostname) => {
-  return dnsLookup(hostname, { all: true, verbatim: false });
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE3, HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR", HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME", EVENTS_STORE_SENTINEL_FILE = "events.json", LOCAL_JSON_EVENT_CURSOR_PREFIX = "local-json-v1:", DEFAULT_EVENT_PAGE_LIMIT = 100, MAX_EVENT_PAGE_LIMIT = 1000, DEFAULT_SIGNATURE_TOLERANCE_MS, DEFAULT_MAX_REDIRECTS = 5, IPV4_PRIVATE_RANGES, IPV6_SPECIAL_PREFIXES, defaultTargetLookup = async (hostname2) => {
+  return dnsLookup(hostname2, { all: true, verbatim: false });
 }, EventValidationError, defaultEventTypeCatalog, APP_EVENT_V1_MAX_DATA_BYTES;
 var init_dist = __esm(() => {
   PATHS_RESOLVER_KIND_ENV = {
@@ -32373,7 +32373,7 @@ var init_event_sink = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.10.1",
+  version: "0.10.3",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -33974,7 +33974,9 @@ import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 
 // src/lib/selection-cache.ts
 import { createHash as createHash3, randomUUID } from "crypto";
-import { closeSync as closeSync5, constants as constants2, fstatSync as fstatSync5, fsyncSync, lstatSync as lstatSync3, mkdirSync as mkdirSync2, openSync as openSync5, readSync as readSync2, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { closeSync as closeSync5, constants as constants2, fstatSync as fstatSync5, fsyncSync, lstatSync as lstatSync3, mkdirSync as mkdirSync2, openSync as openSync5, readFileSync as readFileSync6, readlinkSync, readSync as readSync2, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { hostname } from "os";
 import { dirname as dirname3, join as join7, parse, resolve as resolve2 } from "path";
 import { isDeepStrictEqual } from "util";
 
@@ -35189,6 +35191,166 @@ function readSkillSessionSnapshot(sessionId, options = {}) {
 function skillSessionSnapshotBinding(snapshot) {
   return { sessionId: snapshot.sessionId, generation: snapshot.generation, receiptSha256: snapshot.receiptSha256 };
 }
+var SESSION_LOCK_MAX_BYTES = 4096;
+var SESSION_LOCK_MIN_AGE_MS = 30000;
+function localBootId() {
+  try {
+    if (process.platform === "linux") {
+      const value = readFileSync6("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return /^[a-f0-9-]{36}$/i.test(value) ? value : null;
+    }
+    if (process.platform === "darwin") {
+      const result = spawnSync2("/usr/sbin/sysctl", ["-n", "kern.boottime"], { encoding: "utf8", timeout: 3000, env: { LC_ALL: "C" } });
+      if (result.status !== 0 || result.error)
+        return null;
+      const seconds = /\bsec\s*=\s*(\d+)\b/.exec(result.stdout)?.[1];
+      return seconds ? `darwin:${seconds}` : null;
+    }
+  } catch {}
+  return null;
+}
+function processStart(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return { state: "unknown" };
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync6(`/proc/${pid}/stat`, "utf8");
+      const close = stat.lastIndexOf(")");
+      const start = close < 0 ? undefined : stat.slice(close + 2).trim().split(/\s+/)[19];
+      return start && /^\d+$/.test(start) ? { state: "alive", start: `linux:${start}` } : { state: "unknown" };
+    } catch (error) {
+      return { state: error.code === "ENOENT" ? "absent" : "unknown" };
+    }
+  }
+  if (process.platform === "darwin") {
+    const result = spawnSync2("/bin/ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", timeout: 3000, env: { LC_ALL: "C" } });
+    if (result.error || result.signal)
+      return { state: "unknown" };
+    const start = result.stdout.trim();
+    if (result.status === 1 && !start && !result.stderr.trim())
+      return { state: "absent" };
+    return result.status === 0 && start ? { state: "alive", start: `darwin:${start}` } : { state: "unknown" };
+  }
+  return { state: "unknown" };
+}
+function localLockIdentity() {
+  const bootId = localBootId(), owner = processStart(process.pid);
+  if (!bootId || owner.state !== "alive")
+    return null;
+  let pidNamespace;
+  if (process.platform === "linux") {
+    try {
+      pidNamespace = readlinkSync("/proc/self/ns/pid");
+    } catch {
+      return null;
+    }
+    if (!/^pid:\[\d+\]$/.test(pidNamespace))
+      return null;
+  }
+  return { host: hostname(), bootId, pidNamespace, processStart: owner.start };
+}
+function readSessionLock(sessionId, options) {
+  const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
+  const before = lstatSync3(path, { throwIfNoEntry: false });
+  if (!before)
+    return null;
+  if (!before.isFile() || before.nlink !== 1 || process.getuid && before.uid !== process.getuid()) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is not a private regular file; recovery requires review.");
+  }
+  const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
+  const after = lstatSync3(path, { throwIfNoEntry: false });
+  if (!bytes || !after?.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock changed during inspection; recovery requires review.");
+  }
+  let marker;
+  try {
+    marker = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is unreadable; recovery requires review.");
+  }
+  if (!marker || ![1, 2].includes(marker.schemaVersion) || marker.sessionId !== sessionId || !/^[a-f0-9-]{36}$/i.test(marker.operationId) || !Number.isSafeInteger(marker.pid) || marker.pid <= 0 || marker.schemaVersion === 2 && (!marker.host || !marker.bootId || !marker.processStart || process.platform === "linux" && !marker.pidNamespace)) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock has invalid ownership metadata; recovery requires review.");
+  }
+  return { path, bytes, marker, sha256: sha256Hex(bytes), dev: after.dev, ino: after.ino, mtimeMs: after.mtimeMs };
+}
+function writerIsGone(lock, explicitLocalHost) {
+  if (Date.now() - lock.mtimeMs < SESSION_LOCK_MIN_AGE_MS)
+    return false;
+  const owner = processStart(lock.marker.pid);
+  if (owner.state === "unknown")
+    return false;
+  if (lock.marker.schemaVersion === 1)
+    return explicitLocalHost && owner.state === "absent";
+  const local = localLockIdentity();
+  if (!local || lock.marker.host !== local.host || lock.marker.bootId !== local.bootId || lock.marker.pidNamespace !== local.pidNamespace)
+    return false;
+  return owner.state === "absent" || owner.state === "alive" && owner.start !== lock.marker.processStart;
+}
+function archiveSessionLock(lock, receipt, explicitLocalHost) {
+  const guardPath = `${lock.path}.recovery-guard`;
+  let guardFd;
+  try {
+    guardFd = openSync5(guardPath, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return null;
+    throw error;
+  }
+  const guardStat = fstatSync5(guardFd);
+  try {
+    writeFileSync2(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
+`);
+    fsyncSync(guardFd);
+    const cacheOptions = { cacheDir: dirname3(dirname3(lock.path)) };
+    const current = readSessionLock(lock.marker.sessionId, cacheOptions);
+    if (!current || current.dev !== lock.dev || current.ino !== lock.ino || current.sha256 !== lock.sha256 || current.mtimeMs !== lock.mtimeMs || !writerIsGone(current, explicitLocalHost))
+      return null;
+    const currentReceipt = readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions);
+    if (currentReceipt?.sha256 !== receipt?.sha256 || currentReceipt?.generation !== receipt?.generation)
+      return null;
+    const directory = join7(dirname3(dirname3(lock.path)), "session-lock-recoveries", randomUUID());
+    const archivePath = join7(directory, "original.write-lock");
+    const recordPath = join7(directory, "recovery.json");
+    assertRegularPath(archivePath, true);
+    archiveBytes(recordPath, Buffer.from(`${JSON.stringify({
+      schemaVersion: 1,
+      sessionId: lock.marker.sessionId,
+      originalPath: lock.path,
+      lockSha256: lock.sha256,
+      lockMtime: new Date(lock.mtimeMs).toISOString(),
+      lockPid: lock.marker.pid,
+      receiptSha256: receipt?.sha256 ?? null,
+      receiptGeneration: receipt?.generation ?? null,
+      status: "prepared"
+    })}
+`));
+    syncDirectory(directory);
+    syncDirectory(dirname3(directory));
+    const finalLock = readSessionLock(lock.marker.sessionId, cacheOptions);
+    if (!finalLock || finalLock.dev !== lock.dev || finalLock.ino !== lock.ino || finalLock.sha256 !== lock.sha256 || readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions)?.sha256 !== receipt?.sha256)
+      return null;
+    let moved = false;
+    try {
+      renameSync(lock.path, archivePath);
+      moved = true;
+      syncDirectory(directory);
+      syncDirectory(dirname3(lock.path));
+      if (sha256Hex(readRegularFile(archivePath, SESSION_LOCK_MAX_BYTES)) !== lock.sha256) {
+        throw new Error("Archived lock bytes changed");
+      }
+    } catch (error) {
+      if (moved)
+        throw new SkillSelectionError("SESSION_LOCK_RECOVERY_INCOMPLETE", "The lock moved, but durable recovery could not be confirmed; inspect the preserved recovery directory and session receipt.");
+      throw error;
+    }
+    return archivePath;
+  } finally {
+    closeSync5(guardFd);
+    const current = lstatSync3(guardPath, { throwIfNoEntry: false });
+    if (current?.isFile() && current.dev === guardStat.dev && current.ino === guardStat.ino)
+      unlinkSync(guardPath);
+  }
+}
 function withSessionWriteLocks(sessionIds, options, action) {
   const operationId = randomUUID();
   const locks = [...new Set(sessionIds)].map((sessionId) => ({ sessionId, path: `${sessionReceiptPath(sessionId, options)}.write-lock` })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -35208,13 +35370,30 @@ function withSessionWriteLocks(sessionIds, options, action) {
       try {
         fd = openSync5(lock.path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
       } catch (error) {
-        if (error.code === "EEXIST")
-          throw new SkillSelectionError("SESSION_WRITE_LOCKED", "Another Skills process owns a required session write lock; retry after it completes. A surviving lock requires explicit recovery review.");
-        throw error;
+        if (error.code !== "EEXIST")
+          throw error;
+        try {
+          const stale = readSessionLock(lock.sessionId, options);
+          const receipt = stale && readSkillSessionSnapshotIfExists(lock.sessionId, options);
+          if (stale?.marker.schemaVersion === 2 && writerIsGone(stale, false)) {
+            archiveSessionLock(stale, receipt, false);
+          }
+        } catch (recoveryError) {
+          if (recoveryError instanceof SkillSelectionError && recoveryError.code === "SESSION_LOCK_RECOVERY_INCOMPLETE")
+            throw recoveryError;
+        }
+        try {
+          fd = openSync5(lock.path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+        } catch (retryError) {
+          if (retryError.code === "EEXIST")
+            throw new SkillSelectionError("SESSION_WRITE_LOCKED", "Another Skills process owns a required session write lock; retry after it completes. A surviving legacy lock requires explicit recovery review.");
+          throw retryError;
+        }
       }
       const stat = fstatSync5(fd);
       owned.push({ path: lock.path, fd, dev: stat.dev, ino: stat.ino });
-      writeFileSync2(fd, `${JSON.stringify({ schemaVersion: 1, operationId, sessionId: lock.sessionId, pid: process.pid })}
+      const identity = localLockIdentity();
+      writeFileSync2(fd, `${JSON.stringify({ schemaVersion: identity ? 2 : 1, operationId, sessionId: lock.sessionId, pid: process.pid, ...identity })}
 `);
     }
     return action(assertOwned);
@@ -35341,8 +35520,8 @@ import { hostname as stationHostname } from "os";
 
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP2 } from "net";
-import { spawnSync as spawnSync2 } from "child_process";
-import { closeSync as closeSync6, fstatSync as fstatSync6, openSync as openSync6, readFileSync as readFileSync6 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { closeSync as closeSync6, fstatSync as fstatSync6, openSync as openSync6, readFileSync as readFileSync7 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
@@ -35469,7 +35648,7 @@ function readAppConfigFile2(path) {
       unsafe("the file is not owned by the current user");
     if (before.size > MAX_CREDENTIAL_FILE_BYTES2)
       unsafe("the file exceeds the size limit");
-    const bytes = readFileSync6(fd);
+    const bytes = readFileSync7(fd);
     const after = fstatSync6(fd);
     if (!configFileReadsCoherent2(before, after)) {
       unsafe("the file changed while being read");
@@ -35617,7 +35796,7 @@ function isAmbientEnvironment2(env) {
   return env === process.env || env[AMBIENT_ENVIRONMENT2] === true;
 }
 function defaultKeychainRunner2(argv) {
-  const result = spawnSync2(KEYCHAIN_SECURITY_BIN2, [...argv], {
+  const result = spawnSync3(KEYCHAIN_SECURITY_BIN2, [...argv], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: KEYCHAIN_SPAWN_TIMEOUT_MS2
@@ -37263,7 +37442,7 @@ import { dirname as dirname19, join as join31, resolve as resolve17 } from "path
 import { tmpdir, hostname as stationHostname2 } from "os";
 
 // src/lib/dependency-preparation.ts
-import { constants as constants4, closeSync as closeSync8, fstatSync as fstatSync8, lstatSync as lstatSync4, mkdirSync as mkdirSync3, openSync as openSync8, readFileSync as readFileSync7, readdirSync as readdirSync2, rmdirSync, unlinkSync as unlinkSync2, ftruncateSync, writeSync } from "fs";
+import { constants as constants4, closeSync as closeSync8, fstatSync as fstatSync8, lstatSync as lstatSync4, mkdirSync as mkdirSync3, openSync as openSync8, readFileSync as readFileSync8, readdirSync as readdirSync2, rmdirSync, unlinkSync as unlinkSync2, ftruncateSync, writeSync } from "fs";
 import { join as join9 } from "path";
 
 // src/lib/preparation-process.ts
@@ -37337,7 +37516,7 @@ function claimPreparation(skillPath) {
         return;
       if (!lstatSync4(state).isFile() || lstatSync4(state).isSymbolicLink() || lstatSync4(state).size > 1024)
         return;
-      const previous = JSON.parse(readFileSync7(state, "utf8"));
+      const previous = JSON.parse(readFileSync8(state, "utf8"));
       if (previous.version !== 1 || previous.status !== "failed" || Object.keys(previous).length !== 2)
         return;
     }
@@ -37470,11 +37649,11 @@ async function prepareSkillDependencies(skillPath, env, timeoutMs = DEFAULT_PREP
 }
 
 // src/lib/skillinfo.ts
-import { existsSync as existsSync14, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync21 } from "fs";
 import { join as join30 } from "path";
 
 // src/lib/installer.ts
-import { existsSync as existsSync13, readFileSync as readFileSync19, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync20, rmSync as rmSync4 } from "fs";
 import { join as join29 } from "path";
 import { homedir as homedir6 } from "os";
 
@@ -37485,7 +37664,7 @@ import {
   lstatSync as lstatSync21,
   mkdirSync as mkdirSync8,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readdirSync as readdirSync10,
   renameSync as renameSync5,
   rmSync as rmSync3,
@@ -37516,7 +37695,7 @@ var NATIVE_SKILL_ROOTS = [
 
 // src/lib/agent-integration.ts
 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 { existsSync as existsSync6, lstatSync as lstatSync18, statSync as statSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync14, readdirSync as readdirSync7, opendirSync as opendirSync5, readlinkSync as readlinkSync3, 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";
 
@@ -37705,7 +37884,7 @@ function requiresCliSkillLoading(dataDir2 = getDataDirReadOnly()) {
 
 // src/lib/agent-bridge.ts
 import { createHash as createHash5 } from "crypto";
-import { lstatSync as lstatSync6, readFileSync as readFileSync8, readdirSync as readdirSync3 } from "fs";
+import { lstatSync as lstatSync6, readFileSync as readFileSync9, readdirSync as readdirSync3 } from "fs";
 import { join as join11 } from "path";
 var CLI_BRIDGE_NAME = "skills-cli";
 var CLI_BRIDGE_VERSION = 1;
@@ -37739,7 +37918,7 @@ function isOwnedCliBridge(path, expectedPaths) {
       return false;
     return Object.entries(CLI_BRIDGE_FILES).every(([name, content]) => {
       const file = join11(path, name), stat = lstatSync6(file);
-      return stat.isFile() && !stat.isSymbolicLink() && stat.size === Buffer.byteLength(content) && readFileSync8(file, "utf8") === content;
+      return stat.isFile() && !stat.isSymbolicLink() && stat.size === Buffer.byteLength(content) && readFileSync9(file, "utf8") === content;
     });
   } catch {
     return false;
@@ -37748,7 +37927,7 @@ function isOwnedCliBridge(path, expectedPaths) {
 
 // src/lib/agent-discovery.ts
 import { createHash as createHash15 } from "crypto";
-import { lstatSync as lstatSync17, readFileSync as readFileSync12, readdirSync as readdirSync6, realpathSync as realpathSync3 } from "fs";
+import { lstatSync as lstatSync17, readFileSync as readFileSync13, 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";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 
@@ -37800,7 +37979,7 @@ var $visitAsync = visit.visitAsync;
 
 // src/lib/agent-hermes.ts
 import { dirname as dirname4, isAbsolute as isAbsolute4, join as join12, resolve as resolve4 } from "path";
-import { lstatSync as lstatSync7, readFileSync as readFileSync9, opendirSync } from "fs";
+import { lstatSync as lstatSync7, readFileSync as readFileSync10, opendirSync } from "fs";
 var HERMES_OPT_OUT = ".no-bundled-skills";
 var EVENTS = ["pre_llm_call", "pre_tool_call"];
 function object3(value) {
@@ -37890,7 +38069,7 @@ function read(path) {
     return null;
   if (!stat.isFile() || stat.size > 1024 * 1024)
     throw new Error("NATIVE_SKILL_DRIFT: invalid Hermes protection input");
-  return readFileSync9(path, "utf8");
+  return readFileSync10(path, "utf8");
 }
 function assertHermesProtection(home, config, command, profile, supervisor) {
   assertHermesEnvironment(home);
@@ -38146,7 +38325,7 @@ function hashRawDiscoveryFile(path, budget, changes) {
 
 // src/lib/agent-discovery-path-bytes.ts
 import { createHash as createHash8 } from "crypto";
-import { lstatSync as lstatSync10, readlinkSync } from "fs";
+import { lstatSync as lstatSync10, readlinkSync as readlinkSync2 } from "fs";
 import { dirname as dirname7, isAbsolute as isAbsolute7, join as join14, parse as parse2, resolve as resolve7, sep as sep2 } from "path";
 function identity2(stat, mutable = false) {
   return {
@@ -38202,7 +38381,7 @@ function trace(path) {
     if (stat.isSymbolicLink()) {
       if (++links > AGENT_POLICY_LIMITS.discoveryPathLinks || stat.size > BigInt(AGENT_POLICY_LIMITS.pathCharacters))
         throw new Error("Discovery path link limit exceeded");
-      const rawTarget = readlinkSync(candidate, { encoding: "buffer" }), target = rawTarget.toString("utf8"), after = lstatSync10(candidate, { bigint: true });
+      const rawTarget = readlinkSync2(candidate, { encoding: "buffer" }), target = rawTarget.toString("utf8"), after = lstatSync10(candidate, { bigint: true });
       if (!rawTarget.equals(Buffer.from(target, "utf8")))
         throw new Error("Unsupported non-UTF8 discovery link target");
       if (!target || target.includes("\x00") || Buffer.byteLength(target) > AGENT_POLICY_LIMITS.pathCharacters || !after.isSymbolicLink() || JSON.stringify(identity2(stat, true)) !== JSON.stringify(identity2(after, true)))
@@ -38832,11 +39011,11 @@ function pluginExecutableDigest(path) {
 }
 
 // src/lib/skill-validation.ts
-import { existsSync as existsSync5, lstatSync as lstatSync12, readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { existsSync as existsSync5, lstatSync as lstatSync12, readFileSync as readFileSync12, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
 import { isAbsolute as isAbsolute9, join as join17, normalize } from "path";
 
 // src/lib/hosted-skill-set.ts
-import { existsSync as existsSync4, readFileSync as readFileSync10, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync11, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
 import { join as join16 } from "path";
 var HOSTED_RUNTIMES = new Set(["hosted"]);
 var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
@@ -38854,7 +39033,7 @@ function isHostedMetadataSkillDir(skillDir) {
   if (!existsSync4(pkgPath))
     return false;
   try {
-    return isHostedMetadataPackage(JSON.parse(readFileSync10(pkgPath, "utf8")));
+    return isHostedMetadataPackage(JSON.parse(readFileSync11(pkgPath, "utf8")));
   } catch {
     return false;
   }
@@ -38928,7 +39107,7 @@ function add(target, code, message) {
   target.push({ code, message });
 }
 function readJsonFile(path) {
-  return JSON.parse(readFileSync11(path, "utf-8"));
+  return JSON.parse(readFileSync12(path, "utf-8"));
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -39086,7 +39265,7 @@ function validateSkillDirectory(name, skillPath, registryMeta) {
   }
   const skillMdPath = join17(skillPath, "SKILL.md");
   if (existsSync5(skillMdPath)) {
-    const frontmatter = parseSkillFrontmatter(readFileSync11(skillMdPath, "utf-8"));
+    const frontmatter = parseSkillFrontmatter(readFileSync12(skillMdPath, "utf-8"));
     if (!frontmatter) {
       add(warnings, "skill.frontmatter_missing", "SKILL.md has no YAML frontmatter");
     } else {
@@ -40387,7 +40566,7 @@ function read2(path, changes) {
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
     throw new Error(`Unsupported or oversized native discovery input: ${path}`);
-  return readFileSync12(path, "utf8");
+  return readFileSync13(path, "utf8");
 }
 function projected(source, changes, budget = discoveryByteBudget()) {
   if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || source.hashMode === "claude-settings-v3") {
@@ -40893,7 +41072,7 @@ function readRootAlias(home, agent) {
   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(dirname14(alias), link);
+  const link = readlinkSync3(alias), targetPath = resolve14(dirname14(alias), link);
   assertSafePath(targetPath);
   const targetStat = lstatSync18(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
@@ -41001,8 +41180,8 @@ function selectNativeMigrationTargets(inventory, manifest) {
     if (matches.length !== 1)
       throw new Error(`Native migration target was not found exactly once: ${target.agent} ${target.projectRoot}/${target.path}`);
     const entry = matches[0];
-    if (entry.bridge || entry.system || entry.vendor)
-      throw new Error(`Native migration target is protected or vendor-owned: ${entry.path}`);
+    if (entry.bridge || entry.system || entry.vendor !== (target.vendor === true))
+      throw new Error(`Native migration target is protected or vendor classification changed: ${entry.path}`);
     if (entry.hash !== target.treeSha256 || treeHash(entry.path) !== target.treeSha256)
       throw new Error(`Native migration target changed after review: ${entry.path}`);
     selected.push(entry);
@@ -41025,6 +41204,8 @@ function projectAncestorDirectories(projects) {
   return [...directories];
 }
 function inventoryNativeSkills(home = homedir3(), options = {}) {
+  if (options.reviewedCacheAlias !== undefined && (!options.includeVendor || !isAbsolute15(options.reviewedCacheAlias) || resolve14(options.reviewedCacheAlias) !== options.reviewedCacheAlias))
+    throw new Error("A reviewed cache alias requires vendor inventory and an exact absolute path");
   const aliases = rootAliases(home, options.allowRootAliases);
   const selectedAgents = options.agents ? new Set(options.agents) : undefined;
   const includesAgent = (agent) => !selectedAgents || selectedAgents.has(agent);
@@ -41045,14 +41226,22 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
     if (discoveryPathBytes > 4 * 1024 * 1024)
       throw new Error("Native skill discovery metadata limit exceeded");
   }
-  function emptySiblingCacheAlias(path, parent) {
-    const link = readlinkSync2(path), target = resolve14(parent, link);
+  let reviewedCacheAliasFound = false;
+  function verifiedSiblingCacheAlias(path, parent) {
+    const link = readlinkSync3(path), target = resolve14(parent, link);
     if (dirname14(target) !== parent || (isAbsolute15(link) ? link !== target : dirname14(link) !== "."))
       return false;
     if (!lstatSync18(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
     const scan = cacheScans.get(target);
-    return Boolean(scan?.complete && !scan.hasSkills && scan.entries <= maxAliasProofEntries);
+    if (!scan?.complete || scan.entries > maxAliasProofEntries)
+      return false;
+    if (scan.hasSkills) {
+      if (path !== options.reviewedCacheAlias)
+        return false;
+      reviewedCacheAliasFound = true;
+    }
+    return true;
   }
   function visit2(agent, path, vendor = false, depth = 0, pluginCache = false, admitted = false) {
     if (!admitted)
@@ -41075,7 +41264,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       const marker = join21(path, ".hasna-skills.json");
       if (existsSync6(marker)) {
         try {
-          managed = JSON.parse(readFileSync13(marker, "utf8")).managedBy === "@hasna/skills";
+          managed = JSON.parse(readFileSync14(marker, "utf8")).managedBy === "@hasna/skills";
         } catch {}
       }
       const bridge = !vendor && isOwnedCliBridge(path, bridgePaths);
@@ -41109,7 +41298,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       const child = join21(path, name);
       if (isVendor && lstatSync18(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
         const target = statSync5(child, { throwIfNoEntry: false });
-        if (target?.isFile() || pluginCache && target?.isDirectory() && emptySiblingCacheAlias(child, path)) {
+        if (target?.isFile() || pluginCache && target?.isDirectory() && verifiedSiblingCacheAlias(child, path)) {
           scan.entries++;
           continue;
         }
@@ -41143,12 +41332,14 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
   for (const root2 of [...options.agentRoots ?? [], ...configured])
     if (includesAgent(root2.agent))
       scanRoot(root2.agent, canonicalAgentPath(root2.path, aliases), true);
+  if (options.reviewedCacheAlias !== undefined && !reviewedCacheAliasFound)
+    throw new Error("Reviewed cache alias was not an inventoried skill-containing sibling alias");
   recheckRootAliases(aliases);
   return entries;
 }
 function readOptional(path) {
   assertSafePath(path);
-  return existsSync6(path) ? readFileSync13(path, "utf8") : null;
+  return existsSync6(path) ? readFileSync14(path, "utf8") : null;
 }
 function jsonObject(text2, path) {
   if (text2 === null)
@@ -41862,7 +42053,7 @@ var SKILLS = [];
 
 // src/lib/skill-hash.ts
 import { createHash as createHash17 } from "crypto";
-import { existsSync as existsSync7, readdirSync as readdirSync8, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync8, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
 import { join as join22, sep as sep5 } from "path";
 var CONTENT_HASH_ALGORITHM = "sha256";
 var HASH_EXCLUDE_DIRS = new Set([".git", "node_modules", "dist", "build", ".turbo"]);
@@ -41959,7 +42150,7 @@ function collectDirectory(files, dir, rel) {
   }
 }
 function collectFile(files, absolute, rel) {
-  const buffer = readFileSync14(absolute);
+  const buffer = readFileSync15(absolute);
   files.push(normalizeBundleFile(rel.split(sep5).join("/"), buffer));
 }
 function normalizeBundleFile(rel, buffer) {
@@ -42376,7 +42567,7 @@ import {
   existsSync as existsSync8,
   lstatSync as lstatSync19,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   realpathSync as realpathSync5,
   writeFileSync as writeFileSync5
 } from "fs";
@@ -42441,7 +42632,7 @@ function readManifest(skillPath, fallbackName, normalizeName) {
   const skillMdPath = join23(skillPath, "SKILL.md");
   const pkgPath = join23(skillPath, "package.json");
   const jsonManifest = existsSync8(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync8(skillMdPath) ? parseSkillFrontmatter(readFileSync15(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const frontmatter = existsSync8(skillMdPath) ? parseSkillFrontmatter(readFileSync16(skillMdPath, "utf-8")) ?? undefined : undefined;
   const pkg = existsSync8(pkgPath) ? readJsonObject(pkgPath) : undefined;
   const name = normalizeName(stringField(jsonManifest, "name") ?? frontmatter?.name ?? stringValue(pkg?.name) ?? fallbackName);
   const description = stringField(jsonManifest, "description") ?? frontmatter?.description ?? stringValue(pkg?.description) ?? `${name} skill`;
@@ -42475,7 +42666,7 @@ function readDeclaredSkillVersion(skillPath) {
   const skillMdPath = join23(skillPath, "SKILL.md");
   const pkgPath = join23(skillPath, "package.json");
   const jsonManifest = existsSync8(skillJsonPath) ? readJsonObject(skillJsonPath) : undefined;
-  const frontmatter = existsSync8(skillMdPath) ? parseSkillFrontmatter(readFileSync15(skillMdPath, "utf-8")) ?? undefined : undefined;
+  const frontmatter = existsSync8(skillMdPath) ? parseSkillFrontmatter(readFileSync16(skillMdPath, "utf-8")) ?? undefined : undefined;
   const pkg = existsSync8(pkgPath) ? readJsonObject(pkgPath) : undefined;
   return stringField(jsonManifest, "version") ?? frontmatter?.version ?? stringValue(pkg?.version);
 }
@@ -42596,7 +42787,7 @@ function readExistingSkillJson(skillPath) {
   if (!existsSync8(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync15(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync16(path, "utf-8"));
     return isRecord2(parsed) ? parsed : {};
   } catch {
     return {};
@@ -42633,7 +42824,7 @@ function ensurePortableSkillFiles(skillPath, manifest) {
   if (!existsSync8(join23(skillPath, "SKILL.md")))
     writeFileSync5(join23(skillPath, "SKILL.md"), renderSkillMd(next));
   else
-    writeFileSync5(join23(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync15(join23(skillPath, "SKILL.md"), "utf-8"), next));
+    writeFileSync5(join23(skillPath, "SKILL.md"), ensureSkillMdFrontmatter(readFileSync16(join23(skillPath, "SKILL.md"), "utf-8"), next));
   if (!existsSync8(join23(skillPath, "AGENTS.md")))
     writeFileSync5(join23(skillPath, "AGENTS.md"), renderAgentsMd(next));
   ensurePackageJson(skillPath, next);
@@ -42694,7 +42885,7 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     writeFileSync5(join23(skillPath, "SKILL.md"), renderSkillMd(next));
   } else {
     const path = join23(skillPath, "SKILL.md");
-    const content = readFileSync15(path, "utf8");
+    const content = readFileSync16(path, "utf8");
     const declaredName = parseSkillFrontmatter(content)?.name;
     if (declaredName && declaredName !== next.name) {
       writeFileSync5(path, renameInstructionFrontmatter(content, next.name));
@@ -42986,7 +43177,7 @@ function inferRuntimeFromCommands(commands) {
   return { ...defaultRuntimeContract(entrypoint), runtime: "python3" };
 }
 function readJsonObject(path) {
-  const parsed = JSON.parse(readFileSync15(path, "utf-8"));
+  const parsed = JSON.parse(readFileSync16(path, "utf-8"));
   if (!isRecord2(parsed))
     throw new Error(`${basename7(path)} must contain a JSON object`);
   return parsed;
@@ -43585,7 +43776,7 @@ function hasSkillsOwnershipMarker(dir) {
   try {
     if (!lstatSync21(path).isFile())
       return false;
-    const marker = JSON.parse(readFileSync16(path, "utf8"));
+    const marker = JSON.parse(readFileSync17(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
   } catch {
     return false;
@@ -43794,7 +43985,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
     let existingIsStub = false;
     try {
-      existingIsStub = isPointerSkillMd(readFileSync16(skillMdPath, "utf-8"));
+      existingIsStub = isPointerSkillMd(readFileSync17(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -43874,7 +44065,7 @@ function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = f
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
     const skillMdPath = join26(skillPath, "SKILL.md");
     if (existsSync10(skillMdPath))
-      return readFileSync16(skillMdPath, "utf-8");
+      return readFileSync17(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -43904,7 +44095,7 @@ function normalizeSkillName(name) {
 }
 
 // src/lib/registry.ts
-import { existsSync as existsSync11, readFileSync as readFileSync17, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync18, readdirSync as readdirSync11 } from "fs";
 import { join as join27 } from "path";
 
 // src/lib/registry-merge.ts
@@ -44120,7 +44311,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         continue;
       let content;
       try {
-        content = readFileSync17(skillMdPath, "utf-8");
+        content = readFileSync18(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -44157,7 +44348,7 @@ function findExtensionSkillPath(name) {
         continue;
       let content;
       try {
-        content = readFileSync17(skillMdPath, "utf-8");
+        content = readFileSync18(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -44222,7 +44413,7 @@ function getAllTags() {
 }
 
 // src/lib/project-state.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
 import { join as join28 } from "path";
 var VALID_PIN_SOURCES = [
   "official",
@@ -44248,7 +44439,7 @@ function loadProjectConfig(targetDir = process.cwd()) {
   if (!existsSync12(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync18(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync19(path, "utf-8")));
   } catch {
     return null;
   }
@@ -44435,7 +44626,7 @@ function createLocalSkillManifest(name, generateSkillMd) {
   let skillMd = "";
   const skillMdPath = join29(sourcePath, "SKILL.md");
   if (existsSync13(skillMdPath)) {
-    skillMd = readFileSync19(skillMdPath, "utf-8");
+    skillMd = readFileSync20(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -44554,7 +44745,7 @@ function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
   const skillMdPath = join29(sourcePath, "SKILL.md");
   if (existsSync13(skillMdPath))
-    return readFileSync19(skillMdPath, "utf-8");
+    return readFileSync20(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -44610,14 +44801,14 @@ function readBundledSkillVersion(name) {
   if (!existsSync13(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync13(path) ? readFileSync19(path, "utf-8") : null;
+  return existsSync13(path) ? readFileSync20(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
@@ -44665,7 +44856,7 @@ function isInstructionSkillDir(skillPath, meta) {
   if (!existsSync14(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync20(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync21(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -44716,7 +44907,7 @@ function getSkillRequirements(name) {
   const meta = getSkill(name);
   let dependencies = {};
   try {
-    dependencies = JSON.parse(readFileSync20(join30(skillPath, "package.json"), "utf8")).dependencies || {};
+    dependencies = JSON.parse(readFileSync21(join30(skillPath, "package.json"), "utf8")).dependencies || {};
   } catch {}
   return getSkillRequirementsFromContent(name, texts, dependencies, meta);
 }
@@ -44784,7 +44975,7 @@ async function runSkill(name, args, options = {}) {
   }
   let entryPoint2;
   try {
-    const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync21(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint2 = binValues[0];
@@ -44887,7 +45078,7 @@ function generateSkillMd(name) {
   const pkgPath = join30(skillPath, "package.json");
   if (existsSync14(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync21(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -44963,7 +45154,7 @@ function extractEnvVars(text2) {
 function readIfExists(path) {
   try {
     if (existsSync14(path)) {
-      return readFileSync20(path, "utf-8");
+      return readFileSync21(path, "utf-8");
     }
   } catch {}
   return null;
@@ -55572,7 +55763,7 @@ 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 { mkdirSync as mkdirSync11, readFileSync as readFileSync23, readdirSync as readdirSync12 } from "fs";
 import { dirname as dirname22, join as join35 } from "path";
 
 // src/server/auth.ts
@@ -56626,7 +56817,7 @@ function applySqliteMigrations(db, migrationsDir = resolveMigrationsDir("sqlite"
   const appliedNow = [];
   for (const file of files) {
     const version2 = file.replace(/\.sql$/, "");
-    const text2 = readFileSync22(join35(migrationsDir, file), "utf8");
+    const text2 = readFileSync23(join35(migrationsDir, file), "utf8");
     const apply = db.transaction(() => {
       const already = db.query("SELECT 1 AS present FROM schema_migrations WHERE version = ? LIMIT 1").get(version2);
       if (already)
@@ -63255,15 +63446,11 @@ function resolveServerConfig(env = process.env) {
     requestBodyLimitBytes: parsePositiveInt(env.HASNA_SKILLS_REQUEST_BODY_LIMIT_BYTES, 1e6),
     skillBundleLimitBytes: parsePositiveInt(env.HASNA_SKILLS_BUNDLE_LIMIT_BYTES, 25000000),
     tombstoneWindowMs: parsePositiveInt(env.HASNA_SKILLS_TOMBSTONE_WINDOW_MS, 7 * 24 * 60 * 60 * 1000),
-    publicBaseUrl: (env.SKILLS_PUBLIC_BASE_URL || localOrigin(host, port)).replace(/\/+$/, ""),
+    publicBaseUrl: (env.SKILLS_PUBLIC_BASE_URL || "").replace(/\/+$/, ""),
     nodeEnv,
     allowEphemeralStore: env.HASNA_SKILLS_ALLOW_EPHEMERAL_STORE === "1"
   };
 }
-function localOrigin(host, port) {
-  const hostname = host === "0.0.0.0" || host === "::" ? "localhost" : host;
-  return `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}`;
-}
 function parsePositiveInt(value, fallback) {
   const parsed = Number.parseInt(value ?? "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -64533,6 +64720,9 @@ async function createSkillsFetchHandler(options = {}) {
   const config = { ...resolveServerConfig(), ...options.config };
   if (!options.store)
     assertDurableTarget(resolveDatabaseTarget(config.databaseUrl), config);
+  if (!config.publicBaseUrl) {
+    throw new Error("refusing to start: set SKILLS_PUBLIC_BASE_URL to this Skills server's public API origin; a bound socket is not an authority for client receipts.");
+  }
   const store = options.store ?? await createStore({
     databaseUrl: config.databaseUrl,
     bootstrapApiKey: config.bootstrapApiKey
@@ -69448,7 +69638,7 @@ __export(exports_external2, {
   input: () => input,
   includes: () => _includes,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash3,
   guid: () => guid2,
@@ -71234,7 +71424,7 @@ __export(exports_regexes, {
   idnEmail: () => idnEmail,
   httpProtocol: () => httpProtocol,
   html5Email: () => html5Email,
-  hostname: () => hostname,
+  hostname: () => hostname2,
   hex: () => hex,
   guid: () => guid,
   extendedDuration: () => extendedDuration,
@@ -71296,7 +71486,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+var hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 var domain = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
 var httpProtocol = /^https?$/;
 var e164 = /^\+[1-9]\d{6,14}$/;
@@ -72133,9 +72323,9 @@ var asciiTabOrNewline = /[\t\n\r]/g;
 function stripTabAndNewline(value) {
   return value.replace(asciiTabOrNewline, "");
 }
-function urlHostnameOk(url, hostname2) {
-  hostname2.lastIndex = 0;
-  return hostname2.test(url.hostname);
+function urlHostnameOk(url, hostname3) {
+  hostname3.lastIndex = 0;
+  return hostname3.test(url.hostname);
 }
 function urlProtocolOk(url, protocol) {
   protocol.lastIndex = 0;
@@ -85523,7 +85713,7 @@ __export(exports_schemas2, {
   int: () => int,
   instanceof: () => _instanceof,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash3,
   guid: () => guid2,
@@ -86233,7 +86423,7 @@ var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat"
 function stringFormat(format, fnOrRegex, _params = {}) {
   return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname2(_params) {
+function hostname3(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", exports_regexes.hostname, _params);
 }
 function hex2(_params) {