@hasna/skills 0.10.92 → 0.10.93

package/dist/lib/authoring-path.d.ts

@@ -1,7 +1,12 @@
+import { NativeDiscoveryUnresolved } from "./agent-discovery.js";
 export interface PortableAuthoringPathOptions {
     /** The account whose native discovery must remain free of authored payloads. */
     homeDir?: string;
 }
+/** The authoring form of a native discovery refusal. Authoring commands take
+ * no --discovery-inputs option, so name the command that does, or say that a
+ * review does not resolve it. Names and paths only, never file content. */
+export declare function portableAuthoringDiscoveryRefusal(error: NativeDiscoveryUnresolved, destination: string): string;
 /**
  * Refuse a write target that is, or physically aliases, an agent discovery
  * root. Read-only inventory and archive operations deliberately do not call

package/dist/lib/linux-access-acl.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Linux POSIX ACL absence check (SH-00084).
+ *
+ * Access ACLs change effective permissions independently of mode and group.
+ * The guarded writers do not copy ACLs, so they require verified absence on
+ * supported Linux/glibc. A default ACL initializes direct children at
+ * creation, not existing descendants: query it only for directories where the
+ * caller will create an object.
+ *
+ * Presence is queried only (size 0); no attribute value is read or copied.
+ *
+ * errno is thread-local and any later libc call on this thread, or a signal
+ * handler that does not preserve it, can overwrite it. The probe therefore:
+ * - resets errno before each query where the layer can write it,
+ * - reads it as the very next step after the call, with nothing allocated in
+ *   between (the call returns an immediate number, not a BigInt, and errno is
+ *   read with bun:ffi's read.i32, which allocates nothing),
+ * - re-queries a bounded number of times when the result is -1 with an errno
+ *   other than the two "absent" answers, since a stray overwrite does not
+ *   repeat while a genuine failure does. A persistent failure refuses.
+ * A result other than -1 (the attribute exists, or an anomalous value) always
+ * refuses at once and never depends on errno.
+ */
+/** ENODATA on the asm-generic errno table (Linux x86_64 and aarch64). */
+export declare const LINUX_ENODATA = 61;
+/** EOPNOTSUPP, which glibc also names ENOTSUP, on the asm-generic table. */
+export declare const LINUX_EOPNOTSUPP = 95;
+/** Queries per attribute before an unexplained failure refuses. */
+export declare const LINUX_ACL_QUERY_ATTEMPTS = 4;
+/**
+ * Filesystems where an unsupported POSIX ACL attribute means the kernel
+ * enforces no ACL at all (support compiled out, or mounted with noacl), so
+ * mode and ownership are the whole access model. Network and FUSE filesystems
+ * (NFSv4, SMB, 9p, FUSE and others) also answer EOPNOTSUPP while enforcing
+ * their own ACLs or server-side access, so they stay unverified.
+ */
+export declare const LINUX_ACL_FREE_WHEN_UNSUPPORTED: ReadonlySet<bigint>;
+/** The raw operations, separable so tests can drive every errno path. */
+export interface LinuxAclProbe {
+    /** process.arch of the running binary; only asm-generic errno tables are admitted. */
+    readonly arch: string;
+    /** Thread-local errno of the calling thread, or null when it cannot be located. */
+    readonly errno: {
+        get(): number;
+        set?(value: number): void;
+    } | null;
+    /** fgetxattr(fd, name, NULL, 0): the attribute size, or -1. */
+    fgetxattr(fd: number, attribute: string): number | bigint;
+    /** fstatfs(fd).f_type, or null when fstatfs fails. */
+    filesystemType(fd: number): bigint | null;
+}
+/** True only when every queried POSIX ACL attribute is verifiably absent. */
+export declare function linuxAccessAclAbsent(probe: LinuxAclProbe, fd: number, creationParent: boolean): boolean;
+/** Run with the glibc probe; any loading or ABI failure refuses (false). */
+export declare function withGlibcAclProbe(use: (probe: LinuxAclProbe) => boolean): boolean;

package/dist/runtime-prerequisites.js

@@ -49,7 +49,7 @@ var __require = import.meta.require;
 // src/runtime-prerequisites.ts
 import { isAbsolute as isAbsolute7 } from "path";
 // package.json
-var version = "0.10.92";
+var version = "0.10.93";
 var package_default = {
   name: "@hasna/skills",
   version,

package/dist/sdk/index.js

@@ -91998,7 +91998,7 @@ var init_event_sink = __esm(() => {
   init_dist();
 });
 // package.json
-var version = "0.10.92";
+var version = "0.10.93";
 var package_default = {
   name: "@hasna/skills",
   version,
@@ -105659,6 +105659,19 @@ function discoveryRootUnresolved(agent, command, detail) {
 function isDiscoveryRootUnresolved(error) {
   return error instanceof Error && error.message.startsWith(`${DISCOVERY_ROOT_UNRESOLVED}: `);
 }
+
+class NativeDiscoveryUnresolved extends Error {
+  agent;
+  detail;
+  source;
+  reviewable = false;
+  constructor(agent, detail, source) {
+    super(`Native discovery is unresolved (${agent}: ${detail}); provide a reviewed --discovery-inputs file`);
+    this.agent = agent;
+    this.detail = detail;
+    this.source = source;
+  }
+}
 var quotedPath = (path) => JSON.stringify(path).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
 var realpathOrNull = (path) => {
   try {
@@ -106754,8 +106767,8 @@ function resolveDiscovery(options, exclusion) {
   const configPath = exclusion?.nativeHome === undefined ? agentDiscoveryConfigPath(home, agent) : join34(nativeHome, agent === "codex" ? "config.toml" : "settings.json");
   const configText = witness(configPath, agent === "hermes" ? "yaml" : agent === "codex" ? "toml" : "json", agent === "hermes" ? ["skills", "plugins", "hooks"] : agent === "claude" ? ["enabledPlugins", "extraKnownMarketplaces"] : agent === "codex" ? [...CODEX_DISCOVERY_PROJECTION_FIELDS] : agent === "gemini" ? ["skills", "extensions", "security"] : agent === "opencode" ? ["plugin", "skills"] : agent === "sumi" ? [...SUMI_DISCOVERY_PROJECTION_FIELDS] : ["version"]);
   const config = configText === null ? {} : agent === "hermes" ? parseHermesConfig(configText) : parseConfig(configText, configPath, agent === "codex");
-  const unresolved = (detail) => {
-    throw new Error(`Native discovery is unresolved (${agent}: ${detail}); provide a reviewed --discovery-inputs file`);
+  const unresolved = (detail, source) => {
+    throw new NativeDiscoveryUnresolved(agent, detail, source);
   };
   let opaqueClosureVerified = false;
   const verifyOpaqueClosure = (declarations) => {
@@ -106769,6 +106782,17 @@ function resolveDiscovery(options, exclusion) {
     verifyDiscovery(retained, undefined, undefined, undefined, exclusion?.narrowed, canonical9(configPath));
     opaqueClosureVerified = true;
   };
+  const reviewRemedy = (source, check) => {
+    try {
+      check();
+    } catch (error) {
+      if (error instanceof NativeDiscoveryUnresolved) {
+        error.reviewable = true;
+        error.source ??= source;
+      }
+      throw error;
+    }
+  };
   if (exclusion) {
     if (configText !== null && agent !== "codex" && agent !== "hermes")
       parseNativeJsonObject(configText);
@@ -106840,7 +106864,7 @@ function resolveDiscovery(options, exclusion) {
         unresolved(`non-enumerable ${label} require a current settings review`);
     };
     if (hasHooks)
-      verifyCurrentOpaqueSettings("hooks");
+      reviewRemedy(canonical9(configPath), () => verifyCurrentOpaqueSettings("hooks"));
     if (agent === "claude") {
       if (config.env !== undefined) {
         if (!object6(config.env) || Object.keys(config.env).length > 512)
@@ -106853,7 +106877,7 @@ function resolveDiscovery(options, exclusion) {
         if (hasFunctionHookEnvironment) {
           if (!["0", "1"].includes(config.env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS))
             unresolved("malformed Claude env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS flag");
-          verifyCurrentOpaqueSettings("function-hook environment controls");
+          reviewRemedy(canonical9(configPath), () => verifyCurrentOpaqueSettings("function-hook environment controls"));
         }
       }
       if (config.pluginConfigs !== undefined) {
@@ -106880,7 +106904,7 @@ function resolveDiscovery(options, exclusion) {
         }
         hasPluginConfigs = Object.keys(config.pluginConfigs).length > 0;
         if (hasPluginConfigs)
-          verifyCurrentOpaqueSettings("plugin configurations");
+          reviewRemedy(canonical9(configPath), () => verifyCurrentOpaqueSettings("plugin configurations"));
       }
       if (config.enabledPlugins !== undefined && !object6(config.enabledPlugins))
         unresolved("enabledPlugins must be an object");
@@ -106992,7 +107016,7 @@ function resolveDiscovery(options, exclusion) {
     if (Object.keys(config.enabledPlugins ?? config.plugins ?? config.extensions ?? {}).length > 512)
       unresolved("unbounded native registrations");
     if (hasHooks || hasPluginConfigs || hasFunctionHookEnvironment)
-      verifyOpaqueClosure([]);
+      reviewRemedy(canonical9(configPath), () => verifyOpaqueClosure([]));
   }
   if (options.reviewed && (options.reviewed.version !== 1 || !Array.isArray(options.reviewed.agents) || options.reviewed.agents.some((item) => !item || typeof item !== "object") || new Set(options.reviewed.agents.map((item) => item.agent)).size !== options.reviewed.agents.length))
     throw new Error("Invalid --discovery-inputs version or agents");
@@ -107245,40 +107269,41 @@ function resolveDiscovery(options, exclusion) {
     if (exclusion && Object.keys(manifest).some((key2) => /skill|plugin|hook|marketplace|extension|instruction/i.test(key2) && !["skills", "hooks"].includes(key2)))
       unresolved("unknown plugin discovery controls");
     const hooks = witness(join34(root2, "hooks/hooks.json"));
-    if (manifest.hooks !== undefined || hooks !== null) {
-      if (!exclusion || exclusion.retained?.method !== "reviewed")
-        unresolved("plugin hooks require a separate no-skill-injection review");
-      const required = [manifestPath, ...hooks !== null ? [join34(root2, "hooks/hooks.json")] : []];
-      const scoped2 = agent === "codex" && codex !== undefined ? [] : undefined;
-      if (manifest.hooks !== undefined) {
-        if (scoped2 && manifest.hooks && typeof manifest.hooks === "object" && !Array.isArray(manifest.hooks)) {
-          const inline = codexPluginHookHandlers(manifest.hooks);
-          if (!inline)
-            unresolved("unsupported inline plugin hooks");
-          scoped2.push(inline);
-        } else {
-          if (typeof manifest.hooks !== "string")
-            unresolved("unsupported plugin hooks target");
-          const hook = resolve27(root2, manifest.hooks);
-          if (!hook.startsWith(root2 + sep13))
-            unresolved("plugin hooks target escapes its root");
-          required.push(hook);
-          if (scoped2)
-            scoped2.push(readCodexHookDeclaration(witness(hook), hook));
-        }
-      }
-      if (scoped2 && hooks !== null)
-        scoped2.push(readCodexHookDeclaration(hooks, join34(root2, "hooks/hooks.json")));
-      for (const path of required) {
-        const saved = exclusion.retained.sources.filter((source) => source.path === canonical9(path) && source.sha256 !== null && source.format === undefined && source.fields === undefined);
-        if (saved.length ? saved.some((source) => projected(source, undefined, budget3) !== source.sha256) : !(scoped2 && reviewedInstalledCopy(root2, path, codex)))
-          unresolved("plugin hooks require current independently reviewed sources");
-      }
-      if (scoped2 && scoped2.every((item) => item !== null && item.commands === 0)) {
-        verifyCodexPluginHookClosure(root2, codex, codex.source, new Set(scoped2.flatMap((item) => [...item.servers])), required.map((path) => canonical9(path)));
-      } else
-        verifyOpaqueClosure(required.map((path) => canonical9(path)));
-    }
+    if (manifest.hooks !== undefined || hooks !== null)
+      reviewRemedy(canonical9(hooks !== null ? join34(root2, "hooks/hooks.json") : manifestPath), () => {
+        if (!exclusion || exclusion.retained?.method !== "reviewed")
+          unresolved("plugin hooks require a separate no-skill-injection review");
+        const required = [manifestPath, ...hooks !== null ? [join34(root2, "hooks/hooks.json")] : []];
+        const scoped2 = agent === "codex" && codex !== undefined ? [] : undefined;
+        if (manifest.hooks !== undefined) {
+          if (scoped2 && manifest.hooks && typeof manifest.hooks === "object" && !Array.isArray(manifest.hooks)) {
+            const inline = codexPluginHookHandlers(manifest.hooks);
+            if (!inline)
+              unresolved("unsupported inline plugin hooks");
+            scoped2.push(inline);
+          } else {
+            if (typeof manifest.hooks !== "string")
+              unresolved("unsupported plugin hooks target");
+            const hook = resolve27(root2, manifest.hooks);
+            if (!hook.startsWith(root2 + sep13))
+              unresolved("plugin hooks target escapes its root");
+            required.push(hook);
+            if (scoped2)
+              scoped2.push(readCodexHookDeclaration(witness(hook), hook));
+          }
+        }
+        if (scoped2 && hooks !== null)
+          scoped2.push(readCodexHookDeclaration(hooks, join34(root2, "hooks/hooks.json")));
+        for (const path of required) {
+          const saved = exclusion.retained.sources.filter((source) => source.path === canonical9(path) && source.sha256 !== null && source.format === undefined && source.fields === undefined);
+          if (saved.length ? saved.some((source) => projected(source, undefined, budget3) !== source.sha256) : !(scoped2 && reviewedInstalledCopy(root2, path, codex)))
+            unresolved("plugin hooks require current independently reviewed sources", canonical9(path));
+        }
+        if (scoped2 && scoped2.every((item) => item !== null && item.commands === 0)) {
+          verifyCodexPluginHookClosure(root2, codex, codex.source, new Set(scoped2.flatMap((item) => [...item.servers])), required.map((path) => canonical9(path)));
+        } else
+          verifyOpaqueClosure(required.map((path) => canonical9(path)));
+      });
     const commands = join34(root2, "commands");
     safe6(commands);
     if (agent === "claude" && (manifest.commands !== undefined || lstatSync30(commands, { throwIfNoEntry: false })?.isDirectory() && entries(commands).length))
@@ -107902,6 +107927,82 @@ function assertPinnedLauncherRuntimeSafe(runtime) {
   }
 }
 
+// src/lib/linux-access-acl.ts
+var LINUX_ENODATA = 61;
+var LINUX_EOPNOTSUPP = 95;
+var LINUX_ACL_QUERY_ATTEMPTS = 4;
+var LINUX_ACL_FREE_WHEN_UNSUPPORTED = new Set([
+  0xef53n,
+  0x58465342n,
+  0x9123683en,
+  0x01021994n
+]);
+function queryAttribute(probe2, errno, fd, attribute) {
+  for (let attempt = 0;attempt < LINUX_ACL_QUERY_ATTEMPTS; attempt++) {
+    errno.set?.(0);
+    const result = probe2.fgetxattr(fd, attribute);
+    const code = errno.get();
+    if (result !== -1 && result !== -1n)
+      return "present";
+    if (code === LINUX_ENODATA)
+      return "absent";
+    if (code === LINUX_EOPNOTSUPP)
+      return "unsupported";
+  }
+  return "unverified";
+}
+function linuxAccessAclAbsent(probe2, fd, creationParent) {
+  if (probe2.arch !== "x64" && probe2.arch !== "arm64")
+    return false;
+  const errno = probe2.errno;
+  if (!errno)
+    return false;
+  let unsupported = false;
+  for (const attribute of ["system.posix_acl_access", ...creationParent ? ["system.posix_acl_default"] : []]) {
+    const state = queryAttribute(probe2, errno, fd, attribute);
+    if (state === "present" || state === "unverified")
+      return false;
+    if (state === "unsupported")
+      unsupported = true;
+  }
+  if (!unsupported)
+    return true;
+  const type = probe2.filesystemType(fd);
+  return type !== null && LINUX_ACL_FREE_WHEN_UNSUPPORTED.has(type);
+}
+function withGlibcAclProbe(use) {
+  try {
+    const { dlopen, ptr, read: read3, FFIType } = __require("bun:ffi");
+    const library = dlopen("libc.so.6", {
+      fgetxattr: { args: ["i32", "ptr", "ptr", "u64"], returns: FFIType.i64_fast },
+      fstatfs: { args: ["i32", "ptr"], returns: "i32" },
+      __errno_location: { args: [], returns: "ptr" }
+    });
+    try {
+      const location = library.symbols.__errno_location();
+      const names = new Map;
+      return use({
+        arch: process.arch,
+        errno: location ? { get: () => read3.i32(location) } : null,
+        fgetxattr: (fd, attribute) => {
+          let name = names.get(attribute);
+          if (!name)
+            names.set(attribute, name = Buffer.from(attribute + "\x00"));
+          return library.symbols.fgetxattr(fd, ptr(name), null, 0);
+        },
+        filesystemType: (fd) => {
+          const statfs = new BigUint64Array(32);
+          return library.symbols.fstatfs(fd, ptr(statfs)) === 0 ? statfs[0] : null;
+        }
+      });
+    } finally {
+      library.close();
+    }
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/agent-integration.ts
 var sha5 = (data) => createHash33("sha256").update(data).digest("hex");
 var ROOTS = NATIVE_SKILL_ROOTS;
@@ -108735,28 +108836,7 @@ function hookProjectionRefusal(reason2) {
   throw new Error(`CLAUDE_MANAGED_HOOK_${reason2}`);
 }
 function hasNoLinuxAccessAcl(fd, creationParent) {
-  try {
-    const { dlopen, read: read3, ptr } = __require("bun:ffi");
-    const library = dlopen("libc.so.6", {
-      fgetxattr: { args: ["i32", "ptr", "ptr", "u64"], returns: "i64" },
-      __errno_location: { args: [], returns: "ptr" }
-    });
-    try {
-      const errno = library.symbols.__errno_location();
-      if (!errno)
-        return false;
-      for (const attribute of ["system.posix_acl_access", ...creationParent ? ["system.posix_acl_default"] : []]) {
-        const name = Buffer.from(attribute + "\x00");
-        if (Number(library.symbols.fgetxattr(fd, ptr(name), null, 0)) !== -1 || read3.i32(errno) !== 61)
-          return false;
-      }
-      return true;
-    } finally {
-      library.close();
-    }
-  } catch {
-    return false;
-  }
+  return withGlibcAclProbe((probe2) => linuxAccessAclAbsent(probe2, fd, creationParent));
 }
 function assertNativePathAcl(path, observed, options = {}) {
   if (process.platform !== "darwin" && process.platform !== "linux")
@@ -109697,7 +109777,7 @@ function planCodexPluginNameReconcile(request2) {
     pathDenies: [...pathDenies].sort(),
     ...discovery ? { discovery } : {}
   };
-  const plan = planAgentIntegration({ home, dataDir: dataDir2, projectDir, agents: ["codex"], codexNativeCatalog: catalog, codexReconcile: input });
+  const plan = planAgentIntegration({ home, dataDir: dataDir2, projectDir, agents: ["codex"], codexNativeCatalog: catalog, codexReconcile: input, allowRootAliases: aliases.length > 0 });
   assertCodexReconcileScope(plan, { configPath, policyPath, prior, names, remoteIdentities, discovery: discovery ?? savedDiscovery });
   const configChange = plan.changes.find((change) => resolve28(change.path) === configPath);
   const plannedRules = configChange ? Bun.TOML.parse(configChange.after).skills?.config ?? [] : [];
@@ -111768,6 +111848,11 @@ function physicalPath(path) {
   }
   return resolve29(realpathSync15(cursor), ...suffix);
 }
+function portableAuthoringDiscoveryRefusal(error, destination) {
+  const head = `Native discovery is unresolved (${error.agent}: ${error.detail}).${error.source ? ` Checked source: ${error.source}.` : ""}`;
+  const review = `skills hook install --agent ${error.agent} --discovery-inputs <reviewed-file> --apply`;
+  return error.reviewable ? `${head} Portable Skills authoring stays refused: an unreviewed ${error.agent} hook or plugin option could load skills written to ${destination}. This command takes no --discovery-inputs option; review the current ${error.agent} configuration with ${review}, then retry.` : `${head} Portable Skills authoring stays refused: Skills cannot list every skill root this ${error.agent} configuration registers, so it cannot rule out ${destination}. This command takes no --discovery-inputs option; correct that ${error.agent} configuration entry, then retry. Where a reviewed discovery binding covers it, record one with ${review}.`;
+}
 function contains2(root2, path) {
   const boundary = root2.endsWith(sep16) ? root2 : root2 + sep16;
   return path === root2 || path.startsWith(boundary);
@@ -111868,11 +111953,18 @@ function assertPortableAuthoringPath(path, options = {}) {
   if (native) {
     throw new Error(`Refusing portable Skills authoring below native discovery root '${native}': ${lexical}. Set HASNA_SKILLS_DIR to a private authoring corpus outside native roots.`);
   }
-  const roots = configuredRoots(home, options.homeDir !== undefined);
-  for (const value of selected) {
-    if (physicalPath(value.path) === physicalPath(join38(home, `.${value.agent}`)))
-      continue;
-    roots.push(...resolveAgentDiscoveryExclusionRoots({ home, agent: value.agent, nativeHome: value.path, canonical: physicalPath, executable: null }));
+  const roots = [];
+  try {
+    roots.push(...configuredRoots(home, options.homeDir !== undefined));
+    for (const value of selected) {
+      if (physicalPath(value.path) === physicalPath(join38(home, `.${value.agent}`)))
+        continue;
+      roots.push(...resolveAgentDiscoveryExclusionRoots({ home, agent: value.agent, nativeHome: value.path, canonical: physicalPath, executable: null }));
+    }
+  } catch (error) {
+    if (error instanceof NativeDiscoveryUnresolved)
+      throw new Error(portableAuthoringDiscoveryRefusal(error, lexical));
+    throw error;
   }
   for (const root2 of roots) {
     if (candidates.some((candidate2) => [resolve29(root2), physicalPath(root2)].some((nativeRoot) => contains2(nativeRoot, candidate2) || contains2(candidate2, nativeRoot)))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/skills",
-  "version": "0.10.92",
+  "version": "0.10.93",
   "description": "Skills library for AI coding agents",
   "type": "module",
   "bin": {