@anytio/pspm 0.8.0 → 0.9.2

package/dist/index.js

@@ -5,8 +5,8 @@ import { join, dirname, basename, resolve, relative } from 'path';
 import * as ini from 'ini';
 import ignore from 'ignore';
 import { createHash, randomBytes } from 'crypto';
-import * as semver from 'semver';
-import semver__default from 'semver';
+import * as semver2 from 'semver';
+import semver2__default from 'semver';
 import { checkbox } from '@inquirer/prompts';
 import { readFileSync } from 'fs';
 import { fileURLToPath, URL as URL$1 } from 'url';
@@ -74,7 +74,7 @@ var init_fetcher = __esm({
 });
 
 // src/sdk/generated/index.ts
-var getMeUrl, me, getDeleteSkillUrl, deleteSkill, getListSkillVersionsUrl, listSkillVersions, getGetSkillVersionUrl, getSkillVersion, getDeleteSkillVersionUrl, deleteSkillVersion, getPublishSkillUrl, publishSkill;
+var getMeUrl, me, getExplorePublicSkillsUrl, explorePublicSkills, getDeleteSkillUrl, deleteSkill, getListSkillVersionsUrl, listSkillVersions, getGetSkillVersionUrl, getSkillVersion, getDeleteSkillVersionUrl, deleteSkillVersion, getPublishSkillUrl, publishSkill;
 var init_generated = __esm({
   "src/sdk/generated/index.ts"() {
     init_fetcher();
@@ -90,6 +90,25 @@ var init_generated = __esm({
         }
       );
     };
+    getExplorePublicSkillsUrl = (params) => {
+      const normalizedParams = new URLSearchParams();
+      Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== void 0) {
+          normalizedParams.append(key, value === null ? "null" : value.toString());
+        }
+      });
+      const stringifiedParams = normalizedParams.toString();
+      return stringifiedParams.length > 0 ? `/api/skills/-/explore?${stringifiedParams}` : `/api/skills/-/explore`;
+    };
+    explorePublicSkills = async (params, options) => {
+      return customFetch(
+        getExplorePublicSkillsUrl(params),
+        {
+          ...options,
+          method: "GET"
+        }
+      );
+    };
     getDeleteSkillUrl = (username, name) => {
       return `/api/skills/@user/${username}/${name}`;
     };
@@ -239,6 +258,58 @@ async function undeprecateSkillVersion(username, skillName, version3) {
     };
   }
 }
+async function listGithubSkillVersions(owner, repo, name) {
+  const config2 = getConfig();
+  try {
+    const response = await fetch(
+      `${config2.baseUrl}/api/skills/@github/${owner}/${repo}/${name}/versions`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...config2.apiKey ? { Authorization: `Bearer ${config2.apiKey}` } : {}
+        }
+      }
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      return { status: response.status, error };
+    }
+    const data = await response.json();
+    return { status: response.status, data };
+  } catch (error) {
+    return {
+      status: 500,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function getGithubSkillVersion(owner, repo, name, version3) {
+  const config2 = getConfig();
+  try {
+    const response = await fetch(
+      `${config2.baseUrl}/api/skills/@github/${owner}/${repo}/${name}/versions/${version3}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...config2.apiKey ? { Authorization: `Bearer ${config2.apiKey}` } : {}
+        }
+      }
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      return { status: response.status, error };
+    }
+    const data = await response.json();
+    return { status: response.status, data };
+  } catch (error) {
+    return {
+      status: 500,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
 async function changeSkillAccess(username, skillName, input) {
   const config2 = getConfig();
   if (!config2) {
@@ -368,22 +439,54 @@ var init_errors = __esm({
     };
   }
 });
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearCredentials: () => clearCredentials,
+  findProjectConfig: () => findProjectConfig,
+  getCacheDir: () => getCacheDir,
+  getConfigPath: () => getConfigPath,
+  getLegacyLockfilePath: () => getLegacyLockfilePath,
+  getLegacySkillsDir: () => getLegacySkillsDir,
+  getLockfilePath: () => getLockfilePath,
+  getPspmDir: () => getPspmDir,
+  getRegistryUrl: () => getRegistryUrl,
+  getSkillsDir: () => getSkillsDir,
+  getTokenForRegistry: () => getTokenForRegistry,
+  isGlobalMode: () => isGlobalMode,
+  isLoggedIn: () => isLoggedIn,
+  readUserConfig: () => readUserConfig,
+  requireApiKey: () => requireApiKey,
+  resolveConfig: () => resolveConfig,
+  setCredentials: () => setCredentials,
+  setGlobalMode: () => setGlobalMode,
+  writeUserConfig: () => writeUserConfig
+});
 function getConfigPath() {
   return join(homedir(), ".pspmrc");
 }
 function getLegacyConfigPath() {
   return join(homedir(), ".pspm", "config.json");
 }
+function setGlobalMode(global) {
+  _globalMode = global;
+}
+function isGlobalMode() {
+  return _globalMode;
+}
 function getPspmDir() {
+  if (_globalMode) return join(homedir(), ".pspm");
   return join(process.cwd(), ".pspm");
 }
 function getSkillsDir() {
-  return join(process.cwd(), ".pspm", "skills");
+  return join(getPspmDir(), "skills");
 }
 function getCacheDir() {
-  return join(process.cwd(), ".pspm", "cache");
+  return join(getPspmDir(), "cache");
 }
 function getLockfilePath() {
+  if (_globalMode) return join(homedir(), ".pspm", "pspm-lock.json");
   return join(process.cwd(), "pspm-lock.json");
 }
 function getLegacyLockfilePath() {
@@ -637,11 +740,12 @@ async function getRegistryUrl() {
   const resolved = await resolveConfig();
   return resolved.registryUrl;
 }
-var DEFAULT_REGISTRY_URL;
+var DEFAULT_REGISTRY_URL, _globalMode;
 var init_config = __esm({
   "src/config.ts"() {
     init_errors();
     DEFAULT_REGISTRY_URL = "https://registry.pspm.dev";
+    _globalMode = false;
   }
 });
 async function loadIgnorePatterns(cwd = process.cwd()) {
@@ -734,22 +838,98 @@ var init_manifest = __esm({
     PSPM_SCHEMA_URL = "https://pspm.dev/schema/v1/pspm.json";
   }
 });
-function resolveVersion(range, availableVersions) {
-  const sorted = availableVersions.filter((v) => semver.valid(v)).sort((a, b) => semver.rcompare(a, b));
+var init_integrity2 = __esm({
+  "../../packages/shared/pspm-types/src/integrity.ts"() {
+  }
+});
+
+// ../../packages/shared/pspm-types/src/local.ts
+var init_local = __esm({
+  "../../packages/shared/pspm-types/src/local.ts"() {
+  }
+});
+
+// ../../packages/shared/pspm-types/src/lockfile.ts
+var init_lockfile2 = __esm({
+  "../../packages/shared/pspm-types/src/lockfile.ts"() {
+  }
+});
+
+// ../../packages/shared/pspm-types/src/manifest.ts
+var init_manifest2 = __esm({
+  "../../packages/shared/pspm-types/src/manifest.ts"() {
+  }
+});
+
+// ../../packages/shared/pspm-types/src/specifier.ts
+function parseRegistrySpecifier(specifier) {
+  const match = specifier.match(REGISTRY_SPECIFIER_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const namespace = match[1];
+  const owner = match[2];
+  const name = match[3];
+  const subname = match[4];
+  const versionRange = match[5];
+  if (!owner || !name) {
+    return null;
+  }
+  if (namespace === "github" && !subname) {
+    return null;
+  }
+  if (namespace !== "github" && subname) {
+    return null;
+  }
+  return {
+    namespace,
+    owner,
+    name,
+    subname: subname || void 0,
+    versionRange: versionRange || void 0
+  };
+}
+var REGISTRY_SPECIFIER_PATTERN;
+var init_specifier = __esm({
+  "../../packages/shared/pspm-types/src/specifier.ts"() {
+    REGISTRY_SPECIFIER_PATTERN = /^@(user|org|github)\/([a-zA-Z0-9_-]+)\/([a-zA-Z0-9._-]+)(?:\/([a-z][a-z0-9-]*))?(?:@(.+))?$/;
+  }
+});
+var init_version = __esm({
+  "../../packages/shared/pspm-types/src/version.ts"() {
+  }
+});
+
+// ../../packages/shared/pspm-types/src/index.ts
+var init_src = __esm({
+  "../../packages/shared/pspm-types/src/index.ts"() {
+    init_integrity2();
+    init_local();
+    init_lockfile2();
+    init_manifest2();
+    init_specifier();
+    init_version();
+  }
+});
+function resolveVersion2(range, availableVersions) {
+  const sorted = availableVersions.filter((v) => semver2.valid(v)).sort((a, b) => semver2.rcompare(a, b));
   if (!range || range === "latest" || range === "*") {
     return sorted[0] ?? null;
   }
-  return semver.maxSatisfying(sorted, range);
+  return semver2.maxSatisfying(sorted, range);
+}
+function isNewerVersion2(a, b) {
+  return semver2.gt(a, b);
 }
 function findHighestSatisfying(ranges, availableVersions) {
-  const sorted = availableVersions.filter((v) => semver.valid(v)).sort((a, b) => semver.rcompare(a, b));
+  const sorted = availableVersions.filter((v) => semver2.valid(v)).sort((a, b) => semver2.rcompare(a, b));
   if (sorted.length === 0) return null;
   const normalizedRanges = ranges.map(
     (r) => !r || r === "latest" || r === "*" ? "*" : r
   );
   for (const version3 of sorted) {
     const satisfiesAll = normalizedRanges.every(
-      (range) => semver.satisfies(version3, range)
+      (range) => semver2.satisfies(version3, range)
     );
     if (satisfiesAll) {
       return version3;
@@ -757,7 +937,7 @@ function findHighestSatisfying(ranges, availableVersions) {
   }
   return null;
 }
-var init_version = __esm({
+var init_version2 = __esm({
   "src/lib/version.ts"() {
   }
 });
@@ -820,8 +1000,8 @@ async function resolveRecursive(rootDeps, config2) {
       continue;
     }
     processing.add(name);
-    const match = name.match(/^@user\/([^/]+)\/([^/]+)$/);
-    if (!match) {
+    const parsed = parseRegistrySpecifier(name);
+    if (!parsed) {
       graph.errors.push({
         type: "package_not_found",
         package: name,
@@ -829,10 +1009,23 @@ async function resolveRecursive(rootDeps, config2) {
       });
       continue;
     }
-    const [, username, skillName] = match;
     try {
-      const versionsResponse = await listSkillVersions(username, skillName);
-      if (versionsResponse.status !== 200) {
+      let versionsData;
+      let versionsStatus;
+      if (parsed.namespace === "github" && parsed.subname) {
+        const resp = await listGithubSkillVersions(
+          parsed.owner,
+          parsed.name,
+          parsed.subname
+        );
+        versionsStatus = resp.status;
+        versionsData = resp.data;
+      } else {
+        const resp = await listSkillVersions(parsed.owner, parsed.name);
+        versionsStatus = resp.status;
+        versionsData = resp.status === 200 ? resp.data : void 0;
+      }
+      if (versionsStatus !== 200 || !versionsData) {
         graph.errors.push({
           type: "package_not_found",
           package: name,
@@ -840,8 +1033,7 @@ async function resolveRecursive(rootDeps, config2) {
         });
         continue;
       }
-      const versions = versionsResponse.data;
-      if (versions.length === 0) {
+      if (versionsData.length === 0) {
         graph.errors.push({
           type: "package_not_found",
           package: name,
@@ -849,7 +1041,7 @@ async function resolveRecursive(rootDeps, config2) {
         });
         continue;
       }
-      const availableVersions = versions.map((v) => v.version);
+      const availableVersions = versionsData.map((v) => v.version);
       const resolvedVersion = findHighestSatisfying(
         [versionRange],
         availableVersions
@@ -862,12 +1054,28 @@ async function resolveRecursive(rootDeps, config2) {
         });
         continue;
       }
-      const versionResponse = await getSkillVersion(
-        username,
-        skillName,
-        resolvedVersion
-      );
-      if (versionResponse.status !== 200 || !versionResponse.data) {
+      let versionData = null;
+      if (parsed.namespace === "github" && parsed.subname) {
+        const resp = await getGithubSkillVersion(
+          parsed.owner,
+          parsed.name,
+          parsed.subname,
+          resolvedVersion
+        );
+        if (resp.status === 200 && resp.data) {
+          versionData = resp.data;
+        }
+      } else {
+        const resp = await getSkillVersion(
+          parsed.owner,
+          parsed.name,
+          resolvedVersion
+        );
+        if (resp.status === 200 && resp.data) {
+          versionData = resp.data;
+        }
+      }
+      if (!versionData) {
         graph.errors.push({
           type: "fetch_error",
           package: name,
@@ -875,20 +1083,19 @@ async function resolveRecursive(rootDeps, config2) {
         });
         continue;
       }
-      const versionInfo = versionResponse.data;
-      const manifest = versionInfo.manifest;
+      const manifest = versionData.manifest;
       const dependencies = manifest?.dependencies ?? {};
       const node = {
         name,
         version: resolvedVersion,
         versionRange,
-        downloadUrl: versionInfo.downloadUrl,
-        integrity: `sha256-${Buffer.from(versionInfo.checksum, "hex").toString("base64")}`,
+        downloadUrl: versionData.downloadUrl,
+        integrity: `sha256-${Buffer.from(versionData.checksum, "hex").toString("base64")}`,
         depth,
         dependencies,
         dependents: [dependent],
         isDirect: depth === 0,
-        deprecated: versionInfo.deprecationMessage ?? void 0
+        deprecated: versionData.deprecationMessage ?? void 0
       };
       graph.nodes.set(name, node);
       for (const [depName, depRange] of Object.entries(dependencies)) {
@@ -915,14 +1122,23 @@ async function resolveRecursive(rootDeps, config2) {
     const uniqueDependents = [...new Set(ranges.map((r) => r.dependent))];
     node.dependents = uniqueDependents;
     const allRanges = ranges.map((r) => r.range);
-    const match = name.match(/^@user\/([^/]+)\/([^/]+)$/);
-    if (!match) continue;
-    const [, username, skillName] = match;
+    const p2Parsed = parseRegistrySpecifier(name);
+    if (!p2Parsed) continue;
     try {
-      const versionsResponse = await listSkillVersions(username, skillName);
-      if (versionsResponse.status !== 200) continue;
-      const versions = versionsResponse.data;
-      const availableVersions = versions.map((v) => v.version);
+      let p2Versions;
+      if (p2Parsed.namespace === "github" && p2Parsed.subname) {
+        const resp = await listGithubSkillVersions(
+          p2Parsed.owner,
+          p2Parsed.name,
+          p2Parsed.subname
+        );
+        p2Versions = resp.status === 200 ? resp.data : void 0;
+      } else {
+        const resp = await listSkillVersions(p2Parsed.owner, p2Parsed.name);
+        p2Versions = resp.status === 200 ? resp.data : void 0;
+      }
+      if (!p2Versions) continue;
+      const availableVersions = p2Versions.map((v) => v.version);
       const finalVersion = findHighestSatisfying(allRanges, availableVersions);
       if (!finalVersion) {
         graph.conflicts.push({
@@ -941,18 +1157,33 @@ async function resolveRecursive(rootDeps, config2) {
         continue;
       }
       if (finalVersion !== node.version) {
-        const versionResponse = await getSkillVersion(
-          username,
-          skillName,
-          finalVersion
-        );
-        if (versionResponse.status === 200 && versionResponse.data) {
-          const versionInfo = versionResponse.data;
+        let p2VersionData = null;
+        if (p2Parsed.namespace === "github" && p2Parsed.subname) {
+          const resp = await getGithubSkillVersion(
+            p2Parsed.owner,
+            p2Parsed.name,
+            p2Parsed.subname,
+            finalVersion
+          );
+          if (resp.status === 200 && resp.data) {
+            p2VersionData = resp.data;
+          }
+        } else {
+          const resp = await getSkillVersion(
+            p2Parsed.owner,
+            p2Parsed.name,
+            finalVersion
+          );
+          if (resp.status === 200 && resp.data) {
+            p2VersionData = resp.data;
+          }
+        }
+        if (p2VersionData) {
           node.version = finalVersion;
-          node.downloadUrl = versionInfo.downloadUrl;
-          node.integrity = `sha256-${Buffer.from(versionInfo.checksum, "hex").toString("base64")}`;
-          node.deprecated = versionInfo.deprecationMessage ?? void 0;
-          const manifest = versionInfo.manifest;
+          node.downloadUrl = p2VersionData.downloadUrl;
+          node.integrity = `sha256-${Buffer.from(p2VersionData.checksum, "hex").toString("base64")}`;
+          node.deprecated = p2VersionData.deprecationMessage ?? void 0;
+          const manifest = p2VersionData.manifest;
           node.dependencies = manifest?.dependencies ?? {};
         }
       }
@@ -1067,30 +1298,55 @@ function printResolutionErrors(errors, conflicts = []) {
 var MAX_DEPENDENCY_DEPTH;
 var init_resolver = __esm({
   "src/lib/resolver.ts"() {
+    init_src();
     init_api_client();
-    init_version();
+    init_version2();
     MAX_DEPENDENCY_DEPTH = 5;
   }
 });
 
 // src/lib/specifier.ts
-function parseSkillSpecifier(specifier) {
-  const match = specifier.match(SPECIFIER_PATTERN);
+function parseRegistrySpecifier2(specifier) {
+  const match = specifier.match(REGISTRY_SPECIFIER_PATTERN2);
   if (!match) {
     return null;
   }
-  const username = match[1];
-  const name = match[2];
-  if (!username || !name) {
+  const namespace = match[1];
+  const owner = match[2];
+  const name = match[3];
+  const subname = match[4];
+  const versionRange = match[5];
+  if (!owner || !name) {
+    return null;
+  }
+  if (namespace === "github" && !subname) {
+    return null;
+  }
+  if (namespace !== "github" && subname) {
     return null;
   }
   return {
-    username,
+    namespace,
+    owner,
     name,
-    versionRange: match[3]
+    subname: subname || void 0,
+    versionRange: versionRange || void 0
   };
 }
-function parseGitHubSpecifier(specifier) {
+function generateRegistryIdentifier2(spec) {
+  let base = `@${spec.namespace}/${spec.owner}/${spec.name}`;
+  if (spec.subname) {
+    base += `/${spec.subname}`;
+  }
+  if (spec.versionRange) {
+    base += `@${spec.versionRange}`;
+  }
+  return base;
+}
+function isRegistrySpecifier2(specifier) {
+  return specifier.startsWith("@user/") || specifier.startsWith("@org/") || specifier.startsWith("@github/");
+}
+function parseGitHubSpecifier2(specifier) {
   const match = specifier.match(GITHUB_SPECIFIER_PATTERN);
   if (!match) {
     return null;
@@ -1107,7 +1363,7 @@ function parseGitHubSpecifier(specifier) {
     ref: ref || void 0
   };
 }
-function formatGitHubSpecifier(spec) {
+function formatGitHubSpecifier2(spec) {
   let result = `github:${spec.owner}/${spec.repo}`;
   if (spec.path) {
     result += `/${spec.path}`;
@@ -1117,7 +1373,7 @@ function formatGitHubSpecifier(spec) {
   }
   return result;
 }
-function getGitHubSkillName(spec) {
+function getGitHubSkillName2(spec) {
   if (spec.path) {
     const segments = spec.path.split("/").filter(Boolean);
     const lastSegment = segments[segments.length - 1];
@@ -1127,14 +1383,60 @@ function getGitHubSkillName(spec) {
   }
   return spec.repo;
 }
-function isGitHubSpecifier(specifier) {
+function isGitHubSpecifier2(specifier) {
   return specifier.startsWith("github:");
 }
-var SPECIFIER_PATTERN, GITHUB_SPECIFIER_PATTERN;
-var init_specifier = __esm({
+function isGitHubUrl(input) {
+  return /^https?:\/\/github\.com\/[^/]+\/[^/]+/.test(input);
+}
+function parseGitHubUrl(input) {
+  const treeMatch = input.match(GITHUB_URL_TREE_PATTERN);
+  if (treeMatch) {
+    const [, owner, repo, ref, path] = treeMatch;
+    if (!owner || !repo || !ref) return null;
+    return {
+      owner,
+      repo,
+      ref,
+      path: path || void 0
+    };
+  }
+  const repoMatch = input.match(GITHUB_URL_PATTERN);
+  if (repoMatch) {
+    const [, owner, repo] = repoMatch;
+    if (!owner || !repo) return null;
+    return { owner, repo };
+  }
+  return null;
+}
+function isGitHubShorthand(input) {
+  if (input.includes(":") || input.startsWith(".") || input.startsWith("/") || input.startsWith("@")) {
+    return false;
+  }
+  return GITHUB_SHORTHAND_PATTERN.test(input);
+}
+function parseGitHubShorthand(input) {
+  if (input.includes(":") || input.startsWith(".") || input.startsWith("/") || input.startsWith("@")) {
+    return null;
+  }
+  const match = input.match(GITHUB_SHORTHAND_PATTERN);
+  if (!match) return null;
+  const [, owner, repo, path] = match;
+  if (!owner || !repo) return null;
+  return {
+    owner,
+    repo,
+    path: path || void 0
+  };
+}
+var REGISTRY_SPECIFIER_PATTERN2, GITHUB_SPECIFIER_PATTERN, GITHUB_URL_TREE_PATTERN, GITHUB_URL_PATTERN, GITHUB_SHORTHAND_PATTERN;
+var init_specifier2 = __esm({
   "src/lib/specifier.ts"() {
-    SPECIFIER_PATTERN = /^@user\/([a-zA-Z0-9_-]+)\/([a-z][a-z0-9_-]*)(?:@(.+))?$/;
+    REGISTRY_SPECIFIER_PATTERN2 = /^@(user|org|github)\/([a-zA-Z0-9_-]+)\/([a-zA-Z0-9._-]+)(?:\/([a-z][a-z0-9-]*))?(?:@(.+))?$/;
     GITHUB_SPECIFIER_PATTERN = /^github:([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(\/[^@]+)?(?:@(.+))?$/;
+    GITHUB_URL_TREE_PATTERN = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(?:\/(.+))?$/;
+    GITHUB_URL_PATTERN = /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/;
+    GITHUB_SHORTHAND_PATTERN = /^([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
   }
 });
 
@@ -1146,16 +1448,19 @@ var init_lib = __esm({
     init_lockfile();
     init_manifest();
     init_resolver();
-    init_specifier();
-    init_version();
+    init_specifier2();
+    init_version2();
   }
 });
-function resolveAgentConfig(name, overrides) {
-  if (overrides?.[name]) {
+function resolveAgentConfig(name, overrides, global) {
+  if (!global && overrides?.[name]) {
     return overrides[name];
   }
-  if (name in DEFAULT_AGENT_CONFIGS) {
-    return DEFAULT_AGENT_CONFIGS[name];
+  if (name in AGENT_INFO) {
+    const info = AGENT_INFO[name];
+    return {
+      skillsDir: global ? info.globalSkillsDir : info.skillsDir
+    };
   }
   return null;
 }
@@ -1193,47 +1498,221 @@ var AGENT_INFO, DEFAULT_AGENT_CONFIGS, ALL_AGENTS;
 var init_agents = __esm({
   "src/agents.ts"() {
     AGENT_INFO = {
+      adal: {
+        displayName: "AdaL",
+        skillsDir: ".adal/skills",
+        globalSkillsDir: ".adal/skills"
+      },
+      amp: {
+        displayName: "Amp",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      antigravity: {
+        displayName: "Antigravity",
+        skillsDir: ".agent/skills",
+        globalSkillsDir: ".gemini/antigravity/skills"
+      },
+      augment: {
+        displayName: "Augment",
+        skillsDir: ".augment/skills",
+        globalSkillsDir: ".augment/skills"
+      },
       "claude-code": {
         displayName: "Claude Code",
-        skillsDir: ".claude/skills"
+        skillsDir: ".claude/skills",
+        globalSkillsDir: ".claude/skills"
+      },
+      cline: {
+        displayName: "Cline",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".agents/skills"
+      },
+      codebuddy: {
+        displayName: "CodeBuddy",
+        skillsDir: ".codebuddy/skills",
+        globalSkillsDir: ".codebuddy/skills"
       },
       codex: {
         displayName: "Codex",
-        skillsDir: ".codex/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".codex/skills"
+      },
+      "command-code": {
+        displayName: "Command Code",
+        skillsDir: ".commandcode/skills",
+        globalSkillsDir: ".commandcode/skills"
+      },
+      continue: {
+        displayName: "Continue",
+        skillsDir: ".continue/skills",
+        globalSkillsDir: ".continue/skills"
+      },
+      cortex: {
+        displayName: "Cortex Code",
+        skillsDir: ".cortex/skills",
+        globalSkillsDir: ".snowflake/cortex/skills"
+      },
+      crush: {
+        displayName: "Crush",
+        skillsDir: ".crush/skills",
+        globalSkillsDir: ".config/crush/skills"
       },
       cursor: {
         displayName: "Cursor",
-        skillsDir: ".cursor/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".cursor/skills"
+      },
+      droid: {
+        displayName: "Droid",
+        skillsDir: ".factory/skills",
+        globalSkillsDir: ".factory/skills"
       },
-      gemini: {
+      "gemini-cli": {
         displayName: "Gemini CLI",
-        skillsDir: ".gemini/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".gemini/skills"
+      },
+      "github-copilot": {
+        displayName: "GitHub Copilot",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".copilot/skills"
+      },
+      goose: {
+        displayName: "Goose",
+        skillsDir: ".goose/skills",
+        globalSkillsDir: ".config/goose/skills"
       },
-      kiro: {
+      "iflow-cli": {
+        displayName: "iFlow CLI",
+        skillsDir: ".iflow/skills",
+        globalSkillsDir: ".iflow/skills"
+      },
+      junie: {
+        displayName: "Junie",
+        skillsDir: ".junie/skills",
+        globalSkillsDir: ".junie/skills"
+      },
+      kilo: {
+        displayName: "Kilo Code",
+        skillsDir: ".kilocode/skills",
+        globalSkillsDir: ".kilocode/skills"
+      },
+      "kimi-cli": {
+        displayName: "Kimi Code CLI",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      "kiro-cli": {
         displayName: "Kiro CLI",
-        skillsDir: ".kiro/skills"
+        skillsDir: ".kiro/skills",
+        globalSkillsDir: ".kiro/skills"
+      },
+      kode: {
+        displayName: "Kode",
+        skillsDir: ".kode/skills",
+        globalSkillsDir: ".kode/skills"
+      },
+      mcpjam: {
+        displayName: "MCPJam",
+        skillsDir: ".mcpjam/skills",
+        globalSkillsDir: ".mcpjam/skills"
+      },
+      "mistral-vibe": {
+        displayName: "Mistral Vibe",
+        skillsDir: ".vibe/skills",
+        globalSkillsDir: ".vibe/skills"
+      },
+      mux: {
+        displayName: "Mux",
+        skillsDir: ".mux/skills",
+        globalSkillsDir: ".mux/skills"
+      },
+      neovate: {
+        displayName: "Neovate",
+        skillsDir: ".neovate/skills",
+        globalSkillsDir: ".neovate/skills"
+      },
+      openclaw: {
+        displayName: "OpenClaw",
+        skillsDir: "skills",
+        globalSkillsDir: ".openclaw/skills"
       },
       opencode: {
         displayName: "OpenCode",
-        skillsDir: ".opencode/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/opencode/skills"
+      },
+      openhands: {
+        displayName: "OpenHands",
+        skillsDir: ".openhands/skills",
+        globalSkillsDir: ".openhands/skills"
+      },
+      pi: {
+        displayName: "Pi",
+        skillsDir: ".pi/skills",
+        globalSkillsDir: ".pi/agent/skills"
+      },
+      pochi: {
+        displayName: "Pochi",
+        skillsDir: ".pochi/skills",
+        globalSkillsDir: ".pochi/skills"
+      },
+      qoder: {
+        displayName: "Qoder",
+        skillsDir: ".qoder/skills",
+        globalSkillsDir: ".qoder/skills"
+      },
+      "qwen-code": {
+        displayName: "Qwen Code",
+        skillsDir: ".qwen/skills",
+        globalSkillsDir: ".qwen/skills"
+      },
+      replit: {
+        displayName: "Replit",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      roo: {
+        displayName: "Roo Code",
+        skillsDir: ".roo/skills",
+        globalSkillsDir: ".roo/skills"
+      },
+      trae: {
+        displayName: "Trae",
+        skillsDir: ".trae/skills",
+        globalSkillsDir: ".trae/skills"
+      },
+      "trae-cn": {
+        displayName: "Trae CN",
+        skillsDir: ".trae/skills",
+        globalSkillsDir: ".trae-cn/skills"
+      },
+      universal: {
+        displayName: "Universal",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      windsurf: {
+        displayName: "Windsurf",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: ".codeium/windsurf/skills"
+      },
+      zencoder: {
+        displayName: "Zencoder",
+        skillsDir: ".zencoder/skills",
+        globalSkillsDir: ".zencoder/skills"
       }
     };
-    DEFAULT_AGENT_CONFIGS = {
-      "claude-code": { skillsDir: AGENT_INFO["claude-code"].skillsDir },
-      codex: { skillsDir: AGENT_INFO.codex.skillsDir },
-      cursor: { skillsDir: AGENT_INFO.cursor.skillsDir },
-      gemini: { skillsDir: AGENT_INFO.gemini.skillsDir },
-      kiro: { skillsDir: AGENT_INFO.kiro.skillsDir },
-      opencode: { skillsDir: AGENT_INFO.opencode.skillsDir }
-    };
-    ALL_AGENTS = [
-      "claude-code",
-      "codex",
-      "cursor",
-      "gemini",
-      "kiro",
-      "opencode"
-    ];
+    DEFAULT_AGENT_CONFIGS = Object.fromEntries(
+      Object.entries(AGENT_INFO).map(([key, info]) => [
+        key,
+        { skillsDir: info.skillsDir }
+      ])
+    );
+    ALL_AGENTS = Object.keys(
+      AGENT_INFO
+    ).sort();
   }
 });
 function getGitHubHeaders() {
@@ -1331,13 +1810,13 @@ async function extractGitHubPackage(spec, buffer, skillsDir) {
     const sourcePath = join(tempDir, extractedDir);
     const copySource = spec.path ? join(sourcePath, spec.path) : sourcePath;
     if (spec.path) {
-      const pathExists = await lstat(copySource).catch(() => null);
-      if (!pathExists) {
+      const pathExists2 = await lstat(copySource).catch(() => null);
+      if (!pathExists2) {
         const rootEntries = await readdir(sourcePath);
         const dirs = [];
         for (const entry of rootEntries) {
-          const stat8 = await lstat(join(sourcePath, entry)).catch(() => null);
-          if (stat8?.isDirectory() && !entry.startsWith(".")) {
+          const stat9 = await lstat(join(sourcePath, entry)).catch(() => null);
+          if (stat9?.isDirectory() && !entry.startsWith(".")) {
             dirs.push(entry);
           }
         }
@@ -1485,6 +1964,9 @@ async function writeLockfile(lockfile) {
   if (lockfile.localPackages && Object.keys(lockfile.localPackages).length > 0) {
     normalized.localPackages = lockfile.localPackages;
   }
+  if (lockfile.wellKnownPackages && Object.keys(lockfile.wellKnownPackages).length > 0) {
+    normalized.wellKnownPackages = lockfile.wellKnownPackages;
+  }
   await writeFile(lockfilePath, `${JSON.stringify(normalized, null, 2)}
 `);
 }
@@ -1589,13 +2071,39 @@ async function addLocalToLockfile(specifier, entry) {
   lockfile.localPackages[specifier] = entry;
   await writeLockfile(lockfile);
 }
-var init_lockfile2 = __esm({
+async function addWellKnownToLockfile(specifier, entry) {
+  let lockfile = await readLockfile();
+  if (!lockfile) {
+    lockfile = await createEmptyLockfile();
+  }
+  if (!lockfile.wellKnownPackages) {
+    lockfile.wellKnownPackages = {};
+  }
+  lockfile.wellKnownPackages[specifier] = entry;
+  await writeLockfile(lockfile);
+}
+async function listLockfileWellKnownPackages() {
+  const lockfile = await readLockfile();
+  if (!lockfile?.wellKnownPackages) {
+    return [];
+  }
+  return Object.entries(lockfile.wellKnownPackages).map(
+    ([specifier, entry]) => ({
+      specifier,
+      entry
+    })
+  );
+}
+var init_lockfile3 = __esm({
   "src/lockfile.ts"() {
     init_config();
     init_lib();
   }
 });
 function getManifestPath() {
+  if (isGlobalMode()) {
+    return join(homedir(), ".pspm", "pspm.json");
+  }
   return join(process.cwd(), "pspm.json");
 }
 async function readManifest() {
@@ -1674,8 +2182,23 @@ async function addLocalDependency(specifier, version3 = "*") {
   manifest.localDependencies[specifier] = version3;
   await writeManifest(manifest);
 }
-var init_manifest2 = __esm({
+async function addWellKnownDependency(baseUrl, skillNames) {
+  const manifest = await ensureManifest();
+  if (!manifest.wellKnownDependencies) {
+    manifest.wellKnownDependencies = {};
+  }
+  const existing = manifest.wellKnownDependencies[baseUrl];
+  if (Array.isArray(existing)) {
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...skillNames])];
+    manifest.wellKnownDependencies[baseUrl] = merged;
+  } else {
+    manifest.wellKnownDependencies[baseUrl] = skillNames;
+  }
+  await writeManifest(manifest);
+}
+var init_manifest3 = __esm({
   "src/manifest.ts"() {
+    init_config();
   }
 });
 async function createAgentSymlinks(skills, options) {
@@ -1684,7 +2207,7 @@ async function createAgentSymlinks(skills, options) {
     return;
   }
   for (const agentName of agents) {
-    const config2 = resolveAgentConfig(agentName, agentConfigs);
+    const config2 = resolveAgentConfig(agentName, agentConfigs, options.global);
     if (!config2) {
       console.warn(`Warning: Unknown agent "${agentName}", skipping symlinks`);
       continue;
@@ -1744,8 +2267,19 @@ async function removeAgentSymlinks(skillName, options) {
     }
   }
 }
-function getRegistrySkillPath(username, skillName) {
-  return `.pspm/skills/${username}/${skillName}`;
+function getRegistrySkillPath(ownerOrNamespace, skillNameOrOwner, skillName) {
+  if (skillName !== void 0) {
+    const namespace = ownerOrNamespace;
+    const owner = skillNameOrOwner;
+    if (namespace === "org") {
+      return `.pspm/skills/_org/${owner}/${skillName}`;
+    }
+    if (namespace === "github") {
+      return `.pspm/skills/_github-registry/${owner}/${skillName}`;
+    }
+    return `.pspm/skills/${owner}/${skillName}`;
+  }
+  return `.pspm/skills/${ownerOrNamespace}/${skillNameOrOwner}`;
 }
 function getGitHubSkillPath(owner, repo, path) {
   if (path) {
@@ -1756,6 +2290,9 @@ function getGitHubSkillPath(owner, repo, path) {
 function getLocalSkillPath(skillName) {
   return `.pspm/skills/_local/${skillName}`;
 }
+function getWellKnownSkillPath(hostname, skillName) {
+  return `.pspm/skills/_wellknown/${hostname}/${skillName}`;
+}
 async function getLinkedAgents(skillName, agents, projectRoot, agentConfigs) {
   const linkedAgents = [];
   for (const agentName of agents) {
@@ -1777,13 +2314,189 @@ var init_symlinks = __esm({
     init_agents();
   }
 });
+function isWellKnownSpecifier(input) {
+  if (!input.startsWith("http://") && !input.startsWith("https://")) {
+    return false;
+  }
+  try {
+    const parsed = new URL(input);
+    if (EXCLUDED_HOSTS.includes(parsed.hostname)) {
+      return false;
+    }
+    if (input.endsWith(".git")) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getWellKnownHostname(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.replace(/^www\./, "");
+  } catch {
+    return url;
+  }
+}
+function isValidSkillEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const e = entry;
+  if (typeof e.name !== "string" || e.name.length === 0) return false;
+  if (typeof e.description !== "string" || e.description.length === 0)
+    return false;
+  if (!SKILL_NAME_PATTERN.test(e.name)) return false;
+  if (!Array.isArray(e.files) || e.files.length === 0) return false;
+  let hasSkillMd = false;
+  for (const file of e.files) {
+    if (typeof file !== "string") return false;
+    if (file.startsWith("/") || file.startsWith("\\")) return false;
+    if (file.includes("..")) return false;
+    if (file.toLowerCase() === "skill.md") hasSkillMd = true;
+  }
+  if (!hasSkillMd) return false;
+  return true;
+}
+function isValidIndex(data) {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  if (!Array.isArray(d.skills)) return false;
+  return d.skills.every(isValidSkillEntry);
+}
+async function fetchWellKnownIndex(baseUrl) {
+  const parsed = new URL(baseUrl);
+  const pathRelativeUrl = `${baseUrl.replace(/\/$/, "")}/${WELL_KNOWN_PATH}/${INDEX_FILE}`;
+  const pathRelativeBase = `${baseUrl.replace(/\/$/, "")}/${WELL_KNOWN_PATH}`;
+  try {
+    const response = await fetch(pathRelativeUrl, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (isValidIndex(data)) {
+        return { index: data, resolvedBaseUrl: pathRelativeBase };
+      }
+    }
+  } catch {
+  }
+  const rootUrl = `${parsed.protocol}//${parsed.host}/${WELL_KNOWN_PATH}/${INDEX_FILE}`;
+  const rootBase = `${parsed.protocol}//${parsed.host}/${WELL_KNOWN_PATH}`;
+  if (rootUrl !== pathRelativeUrl) {
+    try {
+      const response = await fetch(rootUrl, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (isValidIndex(data)) {
+          return { index: data, resolvedBaseUrl: rootBase };
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function fetchSkillFiles(baseUrl, entry) {
+  const skillBaseUrl = `${baseUrl}/${entry.name}`;
+  const files = /* @__PURE__ */ new Map();
+  let skillMdContent = "";
+  const results = await Promise.allSettled(
+    entry.files.map(async (filePath) => {
+      const fileUrl = `${skillBaseUrl}/${filePath}`;
+      const response = await fetch(fileUrl, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${fileUrl}: ${response.status}`);
+      }
+      const content = await response.text();
+      return { filePath, content };
+    })
+  );
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      files.set(result.value.filePath, result.value.content);
+      if (result.value.filePath.toLowerCase() === "skill.md") {
+        skillMdContent = result.value.content;
+      }
+    }
+  }
+  if (!skillMdContent) {
+    return null;
+  }
+  return {
+    name: entry.name,
+    description: entry.description,
+    content: skillMdContent,
+    files,
+    sourceUrl: `${skillBaseUrl}/SKILL.md`,
+    indexEntry: entry
+  };
+}
+async function fetchWellKnownSkills(url) {
+  const result = await fetchWellKnownIndex(url);
+  if (!result) return null;
+  const { index, resolvedBaseUrl } = result;
+  const hostname = getWellKnownHostname(url);
+  const skillResults = await Promise.allSettled(
+    index.skills.map((entry) => fetchSkillFiles(resolvedBaseUrl, entry))
+  );
+  const skills = [];
+  for (const r of skillResults) {
+    if (r.status === "fulfilled" && r.value) {
+      skills.push(r.value);
+    }
+  }
+  if (skills.length === 0) return null;
+  return { skills, resolvedBaseUrl, hostname };
+}
+async function extractWellKnownSkill(skill, hostname, skillsDir) {
+  const destPath = join(skillsDir, "_wellknown", hostname, skill.name);
+  await rm(destPath, { recursive: true, force: true });
+  await mkdir(destPath, { recursive: true });
+  for (const [filePath, content] of skill.files) {
+    const fullPath = join(destPath, filePath);
+    if (!fullPath.startsWith(destPath)) {
+      continue;
+    }
+    const { dirname: dirname7 } = await import('path');
+    await mkdir(dirname7(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
+  }
+  return `.pspm/skills/_wellknown/${hostname}/${skill.name}`;
+}
+function calculateWellKnownIntegrity(skill) {
+  const sortedEntries = [...skill.files.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const combined = sortedEntries.map(([path, content]) => `${path}:${content}`).join("\n");
+  return calculateIntegrity(Buffer.from(combined, "utf-8"));
+}
+function getWellKnownDisplayName(hostname, skillName) {
+  return `${hostname}/${skillName} (well-known)`;
+}
+var WELL_KNOWN_PATH, INDEX_FILE, SKILL_NAME_PATTERN, EXCLUDED_HOSTS;
+var init_wellknown = __esm({
+  "src/wellknown.ts"() {
+    init_lib();
+    WELL_KNOWN_PATH = ".well-known/skills";
+    INDEX_FILE = "index.json";
+    SKILL_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/;
+    EXCLUDED_HOSTS = [
+      "github.com",
+      "gitlab.com",
+      "raw.githubusercontent.com"
+    ];
+  }
+});
 
 // src/commands/add.ts
 var add_exports = {};
 __export(add_exports, {
   add: () => add
 });
-function isLocalSpecifier2(specifier) {
+function isLocalSpecifier3(specifier) {
   return specifier.startsWith("file:") || specifier.startsWith("./") || specifier.startsWith("../");
 }
 function parseLocalPath(specifier) {
@@ -1792,27 +2505,43 @@ function parseLocalPath(specifier) {
   }
   return specifier;
 }
-function normalizeToFileSpecifier(path) {
+function normalizeToFileSpecifier2(path) {
   if (path.startsWith("file:")) {
     return path;
   }
   return `file:${path}`;
 }
 async function add(specifiers, options) {
+  if (options.global) {
+    setGlobalMode(true);
+    console.log("Installing globally to ~/.pspm/\n");
+  }
   console.log("Resolving packages...\n");
   const resolvedPackages = [];
   const validationErrors = [];
   for (const specifier of specifiers) {
     try {
-      if (isLocalSpecifier2(specifier)) {
+      if (isLocalSpecifier3(specifier)) {
         const resolved = await validateLocalPackage(specifier);
         resolvedPackages.push(resolved);
-      } else if (isGitHubSpecifier(specifier)) {
+      } else if (isGitHubSpecifier2(specifier) || isGitHubUrl(specifier) || isGitHubShorthand(specifier)) {
         const resolved = await validateGitHubPackage(specifier);
         resolvedPackages.push(resolved);
-      } else {
+      } else if (isWellKnownSpecifier(specifier)) {
+        const resolved = await validateWellKnownPackage(specifier);
+        resolvedPackages.push(resolved);
+      } else if (isRegistrySpecifier2(specifier)) {
         const resolved = await validateRegistryPackage(specifier);
         resolvedPackages.push(resolved);
+      } else {
+        throw new Error(
+          `Unknown specifier format "${specifier}". Supported formats:
+  @user/{username}/{name}[@version]  (registry)
+  @org/{orgname}/{name}[@version]    (organization)
+  github:owner/repo[/path][@ref]     (github)
+  file:./path/to/skill               (local)
+  owner/repo                         (github shorthand)`
+        );
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -1842,11 +2571,19 @@ async function add(specifiers, options) {
   const localPackages = resolvedPackages.filter(
     (p) => p.type === "local"
   );
+  const wellKnownPackages = resolvedPackages.filter(
+    (p) => p.type === "wellknown"
+  );
   let resolutionResult = null;
   if (registryPackages.length > 0) {
     const rootDeps = {};
     for (const pkg of registryPackages) {
-      const fullName = `@user/${pkg.username}/${pkg.name}`;
+      const fullName = generateRegistryIdentifier2({
+        namespace: pkg.namespace,
+        owner: pkg.owner,
+        name: pkg.name,
+        subname: pkg.subname
+      });
       rootDeps[fullName] = pkg.versionRange || `^${pkg.resolvedVersion}`;
     }
     console.log("Resolving dependencies...");
@@ -1944,6 +2681,24 @@ async function add(specifiers, options) {
         error: message
       });
       console.error(`Failed to install ${resolved.specifier}: ${message}
+`);
+    }
+  }
+  for (const resolved of wellKnownPackages) {
+    try {
+      await installWellKnownPackage(resolved, {
+        ...options,
+        resolvedAgents: agents
+      });
+      results.push({ specifier: resolved.specifier, success: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      results.push({
+        specifier: resolved.specifier,
+        success: false,
+        error: message
+      });
+      console.error(`Failed to install ${resolved.specifier}: ${message}
 `);
     }
   }
@@ -1957,12 +2712,15 @@ Summary: ${succeeded} added, ${failed} failed`);
     }
   }
 }
+function getSymlinkRoot() {
+  return isGlobalMode() ? homedir() : process.cwd();
+}
 async function installFromNode(node, options) {
-  const match = node.name.match(/^@user\/([^/]+)\/([^/]+)$/);
-  if (!match) {
+  const parsed = parseRegistrySpecifier2(node.name);
+  if (!parsed) {
     throw new Error(`Invalid package name: ${node.name}`);
   }
-  const [, username, name] = match;
+  const { namespace, owner, name, subname } = parsed;
   console.log(`Installing ${node.name}@${node.version}...`);
   const config2 = await resolveConfig();
   const apiKey = getTokenForRegistry(config2, config2.registryUrl);
@@ -1984,18 +2742,26 @@ async function installFromNode(node, options) {
     throw new Error("Checksum verification failed");
   }
   const skillsDir = getSkillsDir();
-  const destDir = join(skillsDir, username, name);
+  const effectiveSkillName = subname ?? name;
+  let destDir;
+  if (namespace === "org") {
+    destDir = join(skillsDir, "_org", owner, effectiveSkillName);
+  } else if (namespace === "github" && subname) {
+    destDir = join(skillsDir, "_github-registry", owner, name, subname);
+  } else {
+    destDir = join(skillsDir, owner, effectiveSkillName);
+  }
   await mkdir(destDir, { recursive: true });
-  const { writeFile: writeFile10 } = await import('fs/promises');
+  const { writeFile: writeFile11 } = await import('fs/promises');
   const tempFile = join(destDir, ".temp.tgz");
-  await writeFile10(tempFile, tarballBuffer);
+  await writeFile11(tempFile, tarballBuffer);
   const { exec: exec2 } = await import('child_process');
   const { promisify: promisify2 } = await import('util');
   const execAsync = promisify2(exec2);
   try {
     await rm(destDir, { recursive: true, force: true });
     await mkdir(destDir, { recursive: true });
-    await writeFile10(tempFile, tarballBuffer);
+    await writeFile11(tempFile, tarballBuffer);
     await execAsync(
       `tar -xzf "${tempFile}" -C "${destDir}" --strip-components=1`
     );
@@ -2023,14 +2789,16 @@ async function installFromNode(node, options) {
   const agents = options.resolvedAgents;
   if (agents[0] !== "none") {
     const skillManifest = await readManifest();
+    const pathSkillName = namespace === "github" && subname ? `${name}/${subname}` : name;
     const skillInfo = {
-      name,
-      sourcePath: getRegistrySkillPath(username, name)
+      name: effectiveSkillName,
+      sourcePath: getRegistrySkillPath(namespace, owner, pathSkillName)
     };
     await createAgentSymlinks([skillInfo], {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs: skillManifest?.agents
+      projectRoot: getSymlinkRoot(),
+      agentConfigs: skillManifest?.agents,
+      global: isGlobalMode()
     });
   }
   console.log(`Installed ${node.name}@${node.version}`);
@@ -2040,75 +2808,127 @@ async function validateRegistryPackage(specifier) {
   const config2 = await resolveConfig();
   const registryUrl = config2.registryUrl;
   const apiKey = getTokenForRegistry(config2, registryUrl);
-  const parsed = parseSkillSpecifier(specifier);
+  const parsed = parseRegistrySpecifier2(specifier);
   if (!parsed) {
     throw new Error(
-      `Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}[@{version}]`
+      `Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}[@{version}] or @org/{orgname}/{name}[@{version}]`
     );
   }
-  const { username, name, versionRange } = parsed;
+  const { namespace, owner, name, subname, versionRange } = parsed;
+  const fullName = generateRegistryIdentifier2({
+    namespace,
+    owner,
+    name,
+    subname
+  });
   configure2({ registryUrl, apiKey });
   console.log(`Resolving ${specifier}...`);
-  const versionsResponse = await listSkillVersions(username, name);
-  if (versionsResponse.status !== 200) {
-    if (versionsResponse.status === 401) {
-      if (!apiKey) {
+  let versions;
+  if (namespace === "github" && subname) {
+    const versionsResponse = await listGithubSkillVersions(
+      owner,
+      name,
+      subname
+    );
+    if (versionsResponse.status !== 200 || !versionsResponse.data) {
+      if (versionsResponse.status === 401) {
         throw new Error(
-          `Package @user/${username}/${name} requires authentication. Please run 'pspm login' to authenticate`
+          apiKey ? `Access denied to ${fullName}. You may not have permission to access this private package.` : `Package ${fullName} requires authentication. Please run 'pspm login' to authenticate`
         );
       }
-      throw new Error(
-        `Access denied to @user/${username}/${name}. You may not have permission to access this private package.`
+      throw new Error(versionsResponse.error || `Skill ${fullName} not found`);
+    }
+    versions = versionsResponse.data;
+  } else {
+    const versionsResponse = await listSkillVersions(owner, name);
+    if (versionsResponse.status !== 200) {
+      if (versionsResponse.status === 401) {
+        if (!apiKey) {
+          throw new Error(
+            `Package ${fullName} requires authentication. Please run 'pspm login' to authenticate`
+          );
+        }
+        throw new Error(
+          `Access denied to ${fullName}. You may not have permission to access this private package.`
+        );
+      }
+      const errorMessage = extractApiErrorMessage(
+        versionsResponse,
+        `Skill ${fullName} not found`
       );
+      throw new Error(errorMessage);
     }
-    const errorMessage = extractApiErrorMessage(
-      versionsResponse,
-      `Skill @user/${username}/${name} not found`
-    );
-    throw new Error(errorMessage);
+    versions = versionsResponse.data;
   }
-  const versions = versionsResponse.data;
   if (versions.length === 0) {
-    throw new Error(`Skill @user/${username}/${name} not found`);
+    throw new Error(`Skill ${fullName} not found`);
   }
   const versionStrings = versions.map((v) => v.version);
-  const resolvedVersion = resolveVersion(versionRange || "*", versionStrings);
+  const resolvedVersion = resolveVersion2(versionRange || "*", versionStrings);
   if (!resolvedVersion) {
     throw new Error(
-      `No version matching "${versionRange || "latest"}" found for @user/${username}/${name}. Available versions: ${versionStrings.join(", ")}`
+      `No version matching "${versionRange || "latest"}" found for ${fullName}. Available versions: ${versionStrings.join(", ")}`
     );
   }
-  const versionResponse = await getSkillVersion(
-    username,
-    name,
-    resolvedVersion
-  );
-  if (versionResponse.status !== 200 || !versionResponse.data) {
-    const errorMessage = extractApiErrorMessage(
-      versionResponse,
-      `Version ${resolvedVersion} not found`
+  let downloadUrl;
+  let checksum;
+  if (namespace === "github" && subname) {
+    const versionResponse = await getGithubSkillVersion(
+      owner,
+      name,
+      subname,
+      resolvedVersion
     );
-    throw new Error(errorMessage);
+    if (versionResponse.status !== 200 || !versionResponse.data) {
+      throw new Error(`Version ${resolvedVersion} not found for ${fullName}`);
+    }
+    downloadUrl = versionResponse.data.downloadUrl;
+    checksum = versionResponse.data.checksum;
+  } else {
+    const versionResponse = await getSkillVersion(owner, name, resolvedVersion);
+    if (versionResponse.status !== 200 || !versionResponse.data) {
+      const errorMessage = extractApiErrorMessage(
+        versionResponse,
+        `Version ${resolvedVersion} not found`
+      );
+      throw new Error(errorMessage);
+    }
+    downloadUrl = versionResponse.data.downloadUrl;
+    checksum = versionResponse.data.checksum;
   }
-  console.log(`Resolved @user/${username}/${name}@${resolvedVersion}`);
+  console.log(`Resolved ${fullName}@${resolvedVersion}`);
   return {
     type: "registry",
     specifier,
-    username,
+    namespace,
+    owner,
     name,
+    subname,
     versionRange,
     resolvedVersion,
-    versionInfo: {
-      downloadUrl: versionResponse.data.downloadUrl,
-      checksum: versionResponse.data.checksum
-    }
+    versionInfo: { downloadUrl, checksum }
   };
 }
+function parseAnyGitHubFormat(specifier) {
+  if (isGitHubSpecifier2(specifier)) {
+    return parseGitHubSpecifier2(specifier);
+  }
+  if (isGitHubUrl(specifier)) {
+    return parseGitHubUrl(specifier);
+  }
+  if (isGitHubShorthand(specifier)) {
+    return parseGitHubShorthand(specifier);
+  }
+  return null;
+}
 async function validateGitHubPackage(specifier) {
-  const parsed = parseGitHubSpecifier(specifier);
+  const parsed = parseAnyGitHubFormat(specifier);
   if (!parsed) {
     throw new Error(
-      `Invalid GitHub specifier "${specifier}". Use format: github:{owner}/{repo}[/{path}][@{ref}]`
+      `Invalid GitHub specifier "${specifier}". Supported formats:
+  github:owner/repo[/path][@ref]
+  https://github.com/owner/repo[/tree/branch/path]
+  owner/repo[/path]`
     );
   }
   const ref = parsed.ref || "HEAD";
@@ -2134,7 +2954,7 @@ async function installGitHubPackage(resolved, options) {
     downloadResult.buffer,
     skillsDir
   );
-  const lockfileSpecifier = formatGitHubSpecifier({
+  const lockfileSpecifier = formatGitHubSpecifier2({
     owner: parsed.owner,
     repo: parsed.repo,
     path: parsed.path
@@ -2152,15 +2972,16 @@ async function installGitHubPackage(resolved, options) {
   const agents = options.resolvedAgents;
   if (agents[0] !== "none") {
     const manifest = await readManifest();
-    const skillName = getGitHubSkillName(parsed);
+    const skillName = getGitHubSkillName2(parsed);
     const skillInfo = {
       name: skillName,
       sourcePath: getGitHubSkillPath(parsed.owner, parsed.repo, parsed.path)
     };
     await createAgentSymlinks([skillInfo], {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs: manifest?.agents
+      projectRoot: getSymlinkRoot(),
+      agentConfigs: manifest?.agents,
+      global: isGlobalMode()
     });
   }
   console.log(
@@ -2171,7 +2992,7 @@ async function installGitHubPackage(resolved, options) {
 async function validateLocalPackage(specifier) {
   const path = parseLocalPath(specifier);
   const resolvedPath = resolve(process.cwd(), path);
-  const normalizedSpecifier = normalizeToFileSpecifier(path);
+  const normalizedSpecifier = normalizeToFileSpecifier2(path);
   console.log(`Resolving ${specifier}...`);
   try {
     const stats = await stat(resolvedPath);
@@ -2246,13 +3067,72 @@ async function installLocalPackage(resolved, options) {
     };
     await createAgentSymlinks([skillInfo], {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs: manifest?.agents
+      projectRoot: getSymlinkRoot(),
+      agentConfigs: manifest?.agents,
+      global: isGlobalMode()
     });
   }
   console.log(`Installed ${specifier} (local)`);
   console.log(`Location: ${symlinkPath} -> ${resolvedPath}`);
 }
+async function validateWellKnownPackage(specifier) {
+  const hostname = getWellKnownHostname(specifier);
+  console.log(`Discovering skills from ${hostname}...`);
+  const result = await fetchWellKnownSkills(specifier);
+  if (!result) {
+    throw new Error(
+      `No well-known skills found at ${specifier}
+  Expected: ${specifier}/.well-known/skills/index.json`
+    );
+  }
+  console.log(
+    `Found ${result.skills.length} skill(s) from ${hostname}: ${result.skills.map((s) => s.name).join(", ")}`
+  );
+  return {
+    type: "wellknown",
+    specifier,
+    hostname: result.hostname,
+    skills: result.skills,
+    resolvedBaseUrl: result.resolvedBaseUrl
+  };
+}
+async function installWellKnownPackage(resolved, options) {
+  const { specifier, hostname, skills } = resolved;
+  const skillsDir = getSkillsDir();
+  for (const skill of skills) {
+    console.log(
+      `Installing ${getWellKnownDisplayName(hostname, skill.name)}...`
+    );
+    const destPath = await extractWellKnownSkill(skill, hostname, skillsDir);
+    const integrity = calculateWellKnownIntegrity(skill);
+    const lockfileKey = `${specifier}#${skill.name}`;
+    const entry = {
+      version: "well-known",
+      resolved: skill.sourceUrl,
+      integrity,
+      hostname,
+      name: skill.name,
+      files: [...skill.files.keys()]
+    };
+    await addWellKnownToLockfile(lockfileKey, entry);
+    await addWellKnownDependency(specifier, [skill.name]);
+    const agents = options.resolvedAgents;
+    if (agents[0] !== "none") {
+      const manifest = await readManifest();
+      const skillInfo = {
+        name: skill.name,
+        sourcePath: getWellKnownSkillPath(hostname, skill.name)
+      };
+      await createAgentSymlinks([skillInfo], {
+        agents,
+        projectRoot: process.cwd(),
+        agentConfigs: manifest?.agents
+      });
+    }
+    console.log(`Installed ${getWellKnownDisplayName(hostname, skill.name)}`);
+    console.log(`Location: ${destPath}`);
+  }
+}
 var init_add = __esm({
   "src/commands/add.ts"() {
     init_agents();
@@ -2261,9 +3141,10 @@ var init_add = __esm({
     init_errors();
     init_github();
     init_lib();
-    init_lockfile2();
-    init_manifest2();
+    init_lockfile3();
+    init_manifest3();
     init_symlinks();
+    init_wellknown();
   }
 });
 
@@ -2271,7 +3152,7 @@ var init_add = __esm({
 init_api_client();
 init_config();
 init_lib();
-function isLocalSpecifier(specifier) {
+function isLocalSpecifier2(specifier) {
   return specifier.startsWith("file:") || specifier.startsWith("./") || specifier.startsWith("../");
 }
 async function access(specifier, options) {
@@ -2290,8 +3171,8 @@ async function access(specifier, options) {
     let packageName;
     let packageUsername;
     if (specifier) {
-      if (isGitHubSpecifier(specifier)) {
-        const ghSpec = parseGitHubSpecifier(specifier);
+      if (isGitHubSpecifier2(specifier)) {
+        const ghSpec = parseGitHubSpecifier2(specifier);
         if (ghSpec) {
           console.error(`Error: Cannot change visibility of GitHub packages.`);
           console.error(
@@ -2306,7 +3187,7 @@ async function access(specifier, options) {
         }
         process.exit(1);
       }
-      if (isLocalSpecifier(specifier)) {
+      if (isLocalSpecifier2(specifier)) {
         console.error(`Error: Cannot change visibility of local packages.`);
         console.error(
           `  "${specifier}" is a local directory, not a registry package.`
@@ -2316,10 +3197,12 @@ async function access(specifier, options) {
         );
         process.exit(1);
       }
-      const parsed = parseSkillSpecifier(specifier);
+      const parsed = parseRegistrySpecifier2(specifier);
       if (!parsed) {
         console.error(`Error: Invalid package specifier "${specifier}".`);
-        console.error(`  Use format: @user/{username}/{name}`);
+        console.error(
+          `  Use format: @user/{username}/{name} or @org/{orgname}/{name}`
+        );
         console.error(``);
         console.error(`  Examples:`);
         console.error(`    pspm access @user/myname/my-skill --public`);
@@ -2329,21 +3212,21 @@ async function access(specifier, options) {
         process.exit(1);
       }
       packageName = parsed.name;
-      packageUsername = parsed.username;
+      packageUsername = parsed.owner;
     } else {
       const { readFile: readFile10 } = await import('fs/promises');
-      const { join: join16 } = await import('path');
+      const { join: join18 } = await import('path');
       let manifest = null;
       try {
         const content = await readFile10(
-          join16(process.cwd(), "pspm.json"),
+          join18(process.cwd(), "pspm.json"),
           "utf-8"
         );
         manifest = JSON.parse(content);
       } catch {
         try {
           const content = await readFile10(
-            join16(process.cwd(), "package.json"),
+            join18(process.cwd(), "package.json"),
             "utf-8"
           );
           manifest = JSON.parse(content);
@@ -2385,7 +3268,7 @@ async function access(specifier, options) {
     }
     const result = response.data;
     console.log(
-      `+ @user/${result.username}/${result.name} is now ${result.visibility}`
+      `+ @${result.namespace ?? "user"}/${result.username}/${result.name} is now ${result.visibility}`
     );
     if (visibility === "public") {
       console.log("");
@@ -2402,6 +3285,209 @@ async function access(specifier, options) {
 
 // src/commands/index.ts
 init_add();
+
+// src/commands/audit.ts
+init_config();
+init_lib();
+init_lockfile3();
+async function audit(options) {
+  try {
+    const lockfile = await readLockfile();
+    if (!lockfile) {
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            ok: false,
+            issues: [
+              {
+                name: "-",
+                source: "-",
+                severity: "error",
+                type: "no-lockfile",
+                message: "No lockfile found. Run 'pspm install' first."
+              }
+            ]
+          })
+        );
+      } else {
+        console.error("No lockfile found. Run 'pspm install' to create one.");
+      }
+      process.exit(1);
+    }
+    const issues = [];
+    const skillsDir = getSkillsDir();
+    const projectRoot = process.cwd();
+    if (!options.json) {
+      console.log("Auditing installed skills...\n");
+    }
+    const registrySkills = await listLockfileSkills();
+    for (const { name: fullName, entry } of registrySkills) {
+      const match = fullName.match(/^@user\/([^/]+)\/([^/]+)$/);
+      if (!match) continue;
+      const [, username, skillName] = match;
+      const destDir = join(projectRoot, skillsDir, username, skillName);
+      const exists = await pathExists(destDir);
+      if (!exists) {
+        issues.push({
+          name: fullName,
+          source: "registry",
+          severity: "error",
+          type: "missing",
+          message: `Not installed on disk. Run 'pspm install' to restore.`
+        });
+        continue;
+      }
+      if (entry.deprecated) {
+        issues.push({
+          name: fullName,
+          source: "registry",
+          severity: "warning",
+          type: "deprecated",
+          message: `Deprecated: ${entry.deprecated}`
+        });
+      }
+      const skillMdExists = await pathExists(join(destDir, "SKILL.md"));
+      if (!skillMdExists) {
+        issues.push({
+          name: fullName,
+          source: "registry",
+          severity: "warning",
+          type: "integrity",
+          message: "Missing SKILL.md in installed directory. Package may be corrupted."
+        });
+      }
+    }
+    const githubSkills = await listLockfileGitHubPackages();
+    for (const { specifier } of githubSkills) {
+      const parsed = parseGitHubSpecifier2(specifier);
+      if (!parsed) continue;
+      const destDir = parsed.path ? join(
+        projectRoot,
+        skillsDir,
+        "_github",
+        parsed.owner,
+        parsed.repo,
+        parsed.path
+      ) : join(projectRoot, skillsDir, "_github", parsed.owner, parsed.repo);
+      const exists = await pathExists(destDir);
+      if (!exists) {
+        issues.push({
+          name: specifier,
+          source: "github",
+          severity: "error",
+          type: "missing",
+          message: `Not installed on disk. Run 'pspm install' to restore.`
+        });
+        continue;
+      }
+      const skillMdExists = await pathExists(join(destDir, "SKILL.md"));
+      if (!skillMdExists) {
+        issues.push({
+          name: specifier,
+          source: "github",
+          severity: "warning",
+          type: "integrity",
+          message: "Missing SKILL.md in installed directory. Package may be corrupted."
+        });
+      }
+    }
+    const wellKnownSkills = await listLockfileWellKnownPackages();
+    for (const { specifier, entry } of wellKnownSkills) {
+      const wkEntry = entry;
+      const destDir = join(
+        projectRoot,
+        skillsDir,
+        "_wellknown",
+        wkEntry.hostname,
+        wkEntry.name
+      );
+      const exists = await pathExists(destDir);
+      if (!exists) {
+        issues.push({
+          name: specifier,
+          source: "well-known",
+          severity: "error",
+          type: "missing",
+          message: `Not installed on disk. Run 'pspm install' to restore.`
+        });
+        continue;
+      }
+      const skillMdExists = await pathExists(join(destDir, "SKILL.md"));
+      if (!skillMdExists) {
+        issues.push({
+          name: specifier,
+          source: "well-known",
+          severity: "warning",
+          type: "integrity",
+          message: "Missing SKILL.md in installed directory. Package may be corrupted."
+        });
+      }
+    }
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    const warningCount = issues.filter((i) => i.severity === "warning").length;
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: errorCount === 0,
+            totalPackages: registrySkills.length + githubSkills.length + wellKnownSkills.length,
+            issues
+          },
+          null,
+          2
+        )
+      );
+      if (errorCount > 0) process.exit(1);
+      return;
+    }
+    if (issues.length === 0) {
+      const totalPackages2 = registrySkills.length + githubSkills.length + wellKnownSkills.length;
+      console.log(`Audited ${totalPackages2} package(s). No issues found.`);
+      return;
+    }
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    if (errors.length > 0) {
+      console.log("Errors:");
+      for (const issue of errors) {
+        console.log(
+          `  [${issue.type.toUpperCase()}] ${issue.name} (${issue.source})`
+        );
+        console.log(`    ${issue.message}`);
+      }
+      console.log();
+    }
+    if (warnings.length > 0) {
+      console.log("Warnings:");
+      for (const issue of warnings) {
+        console.log(
+          `  [${issue.type.toUpperCase()}] ${issue.name} (${issue.source})`
+        );
+        console.log(`    ${issue.message}`);
+      }
+      console.log();
+    }
+    const totalPackages = registrySkills.length + githubSkills.length + wellKnownSkills.length;
+    console.log(
+      `Audited ${totalPackages} package(s): ${errorCount} error(s), ${warningCount} warning(s).`
+    );
+    if (errorCount > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function configInit(options) {
   try {
     const configPath = join(process.cwd(), ".pspmrc");
@@ -2471,14 +3557,19 @@ async function deprecate(specifier, message, options) {
   try {
     const apiKey = await requireApiKey();
     const registryUrl = await getRegistryUrl();
-    const parsed = parseSkillSpecifier(specifier);
+    const parsed = parseRegistrySpecifier2(specifier);
     if (!parsed) {
       console.error(
-        `Error: Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}@{version}`
+        `Error: Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}@{version} or @org/{orgname}/{name}@{version}`
       );
       process.exit(1);
     }
-    const { username, name, versionRange } = parsed;
+    const { owner, name, versionRange } = parsed;
+    const fullName = generateRegistryIdentifier2({
+      namespace: parsed.namespace,
+      owner,
+      name
+    });
     if (!versionRange) {
       console.error(
         "Error: Version is required for deprecation. Use format: @user/{username}/{name}@{version}"
@@ -2487,23 +3578,15 @@ async function deprecate(specifier, message, options) {
     }
     configure2({ registryUrl, apiKey });
     if (options.undo) {
-      console.log(
-        `Removing deprecation from @user/${username}/${name}@${versionRange}...`
-      );
-      const response = await undeprecateSkillVersion(
-        username,
-        name,
-        versionRange
-      );
+      console.log(`Removing deprecation from ${fullName}@${versionRange}...`);
+      const response = await undeprecateSkillVersion(owner, name, versionRange);
       if (response.status !== 200) {
         console.error(
           `Error: ${response.error || "Failed to remove deprecation"}`
         );
         process.exit(1);
       }
-      console.log(
-        `Removed deprecation from @user/${username}/${name}@${versionRange}`
-      );
+      console.log(`Removed deprecation from ${fullName}@${versionRange}`);
     } else {
       if (!message) {
         console.error(
@@ -2511,9 +3594,9 @@ async function deprecate(specifier, message, options) {
         );
         process.exit(1);
       }
-      console.log(`Deprecating @user/${username}/${name}@${versionRange}...`);
+      console.log(`Deprecating ${fullName}@${versionRange}...`);
       const response = await deprecateSkillVersion(
-        username,
+        owner,
         name,
         versionRange,
         message
@@ -2524,7 +3607,7 @@ async function deprecate(specifier, message, options) {
         );
         process.exit(1);
       }
-      console.log(`Deprecated @user/${username}/${name}@${versionRange}`);
+      console.log(`Deprecated ${fullName}@${versionRange}`);
       console.log(`Message: ${message}`);
       console.log("");
       console.log(
@@ -2764,8 +3847,8 @@ init_config();
 init_errors();
 init_github();
 init_lib();
-init_lockfile2();
-init_manifest2();
+init_lockfile3();
+init_manifest3();
 init_symlinks();
 function getCacheFilePath(cacheDir, integrity) {
   const match = integrity.match(/^sha256-(.+)$/);
@@ -2799,12 +3882,17 @@ async function writeToCache(cacheDir, integrity, data) {
   }
 }
 async function install(specifiers, options) {
+  if (options.global) {
+    const { setGlobalMode: setGlobalMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    setGlobalMode2(true);
+  }
   if (specifiers.length > 0) {
     const { add: add2 } = await Promise.resolve().then(() => (init_add(), add_exports));
     await add2(specifiers, {
       save: true,
       agent: options.agent,
-      yes: options.yes
+      yes: options.yes,
+      global: options.global
     });
     return;
   }
@@ -2845,14 +3933,14 @@ async function installFromLockfile(options) {
 `);
       configure2({ registryUrl, apiKey });
       for (const { fullName, versionRange } of missingDeps) {
-        const parsed = parseSkillSpecifier(fullName);
+        const parsed = parseRegistrySpecifier2(fullName);
         if (!parsed) {
           console.error(`Error: Invalid dependency specifier: ${fullName}`);
           continue;
         }
-        const { username, name } = parsed;
+        const { owner, name } = parsed;
         console.log(`Resolving ${fullName}@${versionRange}...`);
-        const versionsResponse = await listSkillVersions(username, name);
+        const versionsResponse = await listSkillVersions(owner, name);
         if (versionsResponse.status !== 200) {
           const errorMessage = extractApiErrorMessage(
             versionsResponse,
@@ -2869,14 +3957,14 @@ async function installFromLockfile(options) {
         const versionStrings = versions.map(
           (v) => v.version
         );
-        const resolved = resolveVersion(versionRange || "*", versionStrings);
+        const resolved = resolveVersion2(versionRange || "*", versionStrings);
         if (!resolved) {
           console.error(
             `Error: No version matching "${versionRange}" for ${fullName}`
           );
           continue;
         }
-        const versionResponse = await getSkillVersion(username, name, resolved);
+        const versionResponse = await getSkillVersion(owner, name, resolved);
         if (versionResponse.status !== 200 || !versionResponse.data) {
           const errorMessage = extractApiErrorMessage(
             versionResponse,
@@ -2936,7 +4024,7 @@ Resolving ${missingGitHubDeps.length} GitHub dependency(ies)...
 `
       );
       for (const { specifier, ref } of missingGitHubDeps) {
-        const parsed = parseGitHubSpecifier(specifier);
+        const parsed = parseGitHubSpecifier2(specifier);
         if (!parsed) {
           console.error(`Error: Invalid GitHub specifier: ${specifier}`);
           continue;
@@ -2996,12 +4084,12 @@ Installing ${packageCount} registry skill(s)...
       const installOrder = computeInstallOrder(packages);
       const entries = installOrder.filter((name) => packages[name]).map((name) => [name, packages[name]]);
       for (const [fullName, entry] of entries) {
-        const match = fullName.match(/^@user\/([^/]+)\/([^/]+)$/);
-        if (!match) {
+        const parsedName = parseRegistrySpecifier2(fullName);
+        if (!parsedName) {
           console.warn(`Warning: Invalid skill name in lockfile: ${fullName}`);
           continue;
         }
-        const [, username, name] = match;
+        const { namespace: ns, owner: pkgOwner, name, subname } = parsedName;
         console.log(`Installing ${fullName}@${entry.version}...`);
         let tarballBuffer;
         let fromCache = false;
@@ -3050,7 +4138,21 @@ Installing ${packageCount} registry skill(s)...
           }
           await writeToCache(cacheDir, entry.integrity, tarballBuffer);
         }
-        const destDir = join(skillsDir, username, name);
+        const effectiveSkillName = subname ?? name;
+        let destDir;
+        if (ns === "org") {
+          destDir = join(skillsDir, "_org", pkgOwner, effectiveSkillName);
+        } else if (ns === "github" && subname) {
+          destDir = join(
+            skillsDir,
+            "_github-registry",
+            pkgOwner,
+            name,
+            subname
+          );
+        } else {
+          destDir = join(skillsDir, pkgOwner, effectiveSkillName);
+        }
         await rm(destDir, { recursive: true, force: true });
         await mkdir(destDir, { recursive: true });
         const tempFile = join(destDir, ".temp.tgz");
@@ -3068,9 +4170,10 @@ Installing ${packageCount} registry skill(s)...
         console.log(
           `  Installed to ${destDir}${fromCache ? " (from cache)" : ""}`
         );
+        const pathSkillName = ns === "github" && subname ? `${name}/${subname}` : name;
         installedSkills.push({
-          name,
-          sourcePath: getRegistrySkillPath(username, name)
+          name: effectiveSkillName,
+          sourcePath: getRegistrySkillPath(ns, pkgOwner, pathSkillName)
         });
       }
     }
@@ -3081,7 +4184,7 @@ Installing ${packageCount} registry skill(s)...
 Installing ${githubCount} GitHub skill(s)...
 `);
       for (const [specifier, entry] of Object.entries(githubPackages)) {
-        const parsed = parseGitHubSpecifier(specifier);
+        const parsed = parseGitHubSpecifier2(specifier);
         if (!parsed) {
           console.warn(
             `Warning: Invalid GitHub specifier in lockfile: ${specifier}`
@@ -3136,7 +4239,7 @@ Installing ${githubCount} GitHub skill(s)...
           console.log(
             `  Installed to ${destPath}${fromCache ? " (from cache)" : ""}`
           );
-          const skillName = getGitHubSkillName(parsed);
+          const skillName = getGitHubSkillName2(parsed);
           installedSkills.push({
             name: skillName,
             sourcePath: getGitHubSkillPath(
@@ -3152,12 +4255,16 @@ Installing ${githubCount} GitHub skill(s)...
       }
     }
     if (installedSkills.length > 0 && agents[0] !== "none") {
-      console.log(`
-Creating symlinks for agent(s): ${agents.join(", ")}...`);
+      const globalMode = isGlobalMode();
+      console.log(
+        `
+Creating symlinks for agent(s): ${agents.join(", ")}${globalMode ? " (global)" : ""}...`
+      );
       await createAgentSymlinks(installedSkills, {
         agents,
-        projectRoot: process.cwd(),
-        agentConfigs
+        projectRoot: globalMode ? homedir() : process.cwd(),
+        agentConfigs,
+        global: globalMode
       });
       console.log("  Symlinks created.");
     }
@@ -3178,11 +4285,15 @@ All ${totalCount} skill(s) installed.`);
 // src/commands/link.ts
 init_agents();
 init_lib();
-init_lockfile2();
-init_manifest2();
+init_lockfile3();
+init_manifest3();
 init_symlinks();
 async function link(options) {
   try {
+    if (options.global) {
+      const { setGlobalMode: setGlobalMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      setGlobalMode2(true);
+    }
     const manifest = await readManifest();
     const agentConfigs = manifest?.agents;
     let agents;
@@ -3203,26 +4314,32 @@ async function link(options) {
     const skills = [];
     const registrySkills = await listLockfileSkills();
     for (const { name } of registrySkills) {
-      const parsed = parseSkillSpecifier(name);
+      const parsed = parseRegistrySpecifier2(name);
       if (!parsed) {
         console.warn(`Warning: Invalid skill name in lockfile: ${name}`);
         continue;
       }
+      const effectiveName = parsed.subname ?? parsed.name;
+      const pathName = parsed.namespace === "github" && parsed.subname ? `${parsed.name}/${parsed.subname}` : parsed.name;
       skills.push({
-        name: parsed.name,
-        sourcePath: getRegistrySkillPath(parsed.username, parsed.name)
+        name: effectiveName,
+        sourcePath: getRegistrySkillPath(
+          parsed.namespace,
+          parsed.owner,
+          pathName
+        )
       });
     }
     const githubSkills = await listLockfileGitHubPackages();
     for (const { specifier } of githubSkills) {
-      const parsed = parseGitHubSpecifier(specifier);
+      const parsed = parseGitHubSpecifier2(specifier);
       if (!parsed) {
         console.warn(
           `Warning: Invalid GitHub specifier in lockfile: ${specifier}`
         );
         continue;
       }
-      const skillName = getGitHubSkillName(parsed);
+      const skillName = getGitHubSkillName2(parsed);
       skills.push({
         name: skillName,
         sourcePath: getGitHubSkillPath(parsed.owner, parsed.repo, parsed.path)
@@ -3235,10 +4352,12 @@ async function link(options) {
     console.log(
       `Creating symlinks for ${skills.length} skill(s) to agent(s): ${agents.join(", ")}...`
     );
+    const globalMode = options.global ?? false;
     await createAgentSymlinks(skills, {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs
+      projectRoot: globalMode ? (await import('os')).homedir() : process.cwd(),
+      agentConfigs,
+      global: globalMode
     });
     console.log("Symlinks created successfully.");
     console.log("\nLinked skills:");
@@ -3255,23 +4374,33 @@ async function link(options) {
 // src/commands/list.ts
 init_agents();
 init_lib();
-init_lockfile2();
-init_manifest2();
+init_lockfile3();
+init_manifest3();
 init_symlinks();
 async function list(options) {
   try {
+    if (options.global) {
+      const { setGlobalMode: setGlobalMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      setGlobalMode2(true);
+    }
     const registrySkills = await listLockfileSkills();
     const githubSkills = await listLockfileGitHubPackages();
+    const wellKnownSkills = await listLockfileWellKnownPackages();
     const manifest = await readManifest();
     const agentConfigs = manifest?.agents;
     const availableAgents = getAvailableAgents(agentConfigs);
     const projectRoot = process.cwd();
     const skills = [];
     for (const { name: fullName, entry } of registrySkills) {
-      const match = fullName.match(/^@user\/([^/]+)\/([^/]+)$/);
-      if (!match) continue;
-      const [, username, skillName] = match;
-      const sourcePath = getRegistrySkillPath(username, skillName);
+      const parsed = parseRegistrySpecifier2(fullName);
+      if (!parsed) continue;
+      const skillName = parsed.subname ?? parsed.name;
+      const pathName = parsed.namespace === "github" && parsed.subname ? `${parsed.name}/${parsed.subname}` : parsed.name;
+      const sourcePath = getRegistrySkillPath(
+        parsed.namespace,
+        parsed.owner,
+        pathName
+      );
       const absolutePath = join(projectRoot, sourcePath);
       let status = "installed";
       try {
@@ -3296,10 +4425,10 @@ async function list(options) {
       });
     }
     for (const { specifier, entry } of githubSkills) {
-      const parsed = parseGitHubSpecifier(specifier);
+      const parsed = parseGitHubSpecifier2(specifier);
       if (!parsed) continue;
       const ghEntry = entry;
-      const skillName = getGitHubSkillName(parsed);
+      const skillName = getGitHubSkillName2(parsed);
       const sourcePath = getGitHubSkillPath(
         parsed.owner,
         parsed.repo,
@@ -3330,6 +4459,34 @@ async function list(options) {
         gitCommit: ghEntry.gitCommit
       });
     }
+    for (const { specifier, entry } of wellKnownSkills) {
+      const wkEntry = entry;
+      const skillName = wkEntry.name;
+      const sourcePath = getWellKnownSkillPath(wkEntry.hostname, skillName);
+      const absolutePath = join(projectRoot, sourcePath);
+      let status = "installed";
+      try {
+        await access$1(absolutePath);
+      } catch {
+        status = "missing";
+      }
+      const linkedAgents = await getLinkedAgents(
+        skillName,
+        availableAgents,
+        projectRoot,
+        agentConfigs
+      );
+      skills.push({
+        name: skillName,
+        fullName: specifier,
+        version: "well-known",
+        source: "well-known",
+        sourcePath,
+        status,
+        linkedAgents,
+        hostname: wkEntry.hostname
+      });
+    }
     if (skills.length === 0) {
       console.log("No skills installed.");
       return;
@@ -3342,6 +4499,8 @@ async function list(options) {
     for (const skill of skills) {
       if (skill.source === "registry") {
         console.log(`  ${skill.fullName}@${skill.version} (registry)`);
+      } else if (skill.source === "well-known") {
+        console.log(`  ${skill.name} (well-known: ${skill.hostname})`);
       } else {
         const refInfo = skill.gitRef ? `${skill.gitRef}@${skill.gitCommit?.slice(0, 7)}` : skill.version;
         console.log(`  ${skill.fullName} (${refInfo})`);
@@ -3360,9 +4519,13 @@ async function list(options) {
     }
     const registryCount = skills.filter((s) => s.source === "registry").length;
     const githubCount = skills.filter((s) => s.source === "github").length;
+    const wellKnownCount = skills.filter(
+      (s) => s.source === "well-known"
+    ).length;
     const parts = [];
     if (registryCount > 0) parts.push(`${registryCount} registry`);
     if (githubCount > 0) parts.push(`${githubCount} github`);
+    if (wellKnownCount > 0) parts.push(`${wellKnownCount} well-known`);
     console.log(`
 Total: ${skills.length} skill(s) (${parts.join(", ")})`);
   } catch (error) {
@@ -3579,7 +4742,7 @@ async function logout() {
 
 // src/commands/migrate.ts
 init_config();
-init_lockfile2();
+init_lockfile3();
 async function migrate(options) {
   try {
     const legacySkillsDir = getLegacySkillsDir();
@@ -3679,20 +4842,20 @@ async function migrate(options) {
     process.exit(1);
   }
 }
-function resolveVersion2(range, availableVersions) {
-  const sorted = availableVersions.filter((v) => semver.valid(v)).sort((a, b) => semver.rcompare(a, b));
+function resolveVersion3(range, availableVersions) {
+  const sorted = availableVersions.filter((v) => semver2.valid(v)).sort((a, b) => semver2.rcompare(a, b));
   if (range === "latest") {
     return sorted[0] ?? null;
   }
-  return semver.maxSatisfying(sorted, range);
+  return semver2.maxSatisfying(sorted, range);
 }
-function compareVersions2(a, b) {
-  return semver.compare(a, b);
+function compareVersions3(a, b) {
+  return semver2.compare(a, b);
 }
-function getLatestVersion2(versions) {
-  const valid3 = versions.filter((v) => semver.valid(v));
-  if (valid3.length === 0) return null;
-  return valid3.sort((a, b) => semver.rcompare(a, b))[0];
+function getLatestVersion3(versions) {
+  const valid5 = versions.filter((v) => semver2.valid(v));
+  if (valid5.length === 0) return null;
+  return valid5.sort((a, b) => semver2.rcompare(a, b))[0];
 }
 
 // ../../packages/server/skill-registry/src/client/outdated.ts
@@ -3725,14 +4888,14 @@ function createOutdatedChecker(config2) {
       const versions = await fetchRegistryVersions(username, name);
       const versionStrings = versions.map((v) => v.version);
       const range = versionRange || "*";
-      const wanted = resolveVersion2(range, versionStrings);
-      const latest = getLatestVersion2(versionStrings);
+      const wanted = resolveVersion3(range, versionStrings);
+      const latest = getLatestVersion3(versionStrings);
       const currentVersionInfo = versions.find(
         (v) => v.version === entry.version
       );
       const deprecated = currentVersionInfo?.deprecationMessage ?? void 0;
-      const isOutdated = wanted !== null && compareVersions2(entry.version, wanted) < 0 || latest !== null && compareVersions2(entry.version, latest) < 0;
-      const wantedBehindLatest = wanted !== null && latest !== null && compareVersions2(wanted, latest) < 0;
+      const isOutdated = wanted !== null && compareVersions3(entry.version, wanted) < 0 || latest !== null && compareVersions3(entry.version, latest) < 0;
+      const wantedBehindLatest = wanted !== null && latest !== null && compareVersions3(wanted, latest) < 0;
       return {
         name: specifier,
         current: entry.version,
@@ -3865,8 +5028,8 @@ async function checkOutdated(config2, options) {
 
 // src/commands/outdated.ts
 init_config();
-init_lockfile2();
-init_manifest2();
+init_lockfile3();
+init_manifest3();
 async function outdated(packages, options) {
   try {
     const lockfile = await readLockfile();
@@ -4074,8 +5237,8 @@ async function publishCommand(options) {
       dependencies: manifest.dependencies
     };
     if (options.bump) {
-      const semver4 = await import('semver');
-      const newVersion = semver4.default.inc(packageJson2.version, options.bump);
+      const semver6 = await import('semver');
+      const newVersion = semver6.default.inc(packageJson2.version, options.bump);
       if (!newVersion) {
         console.error(
           `Error: Failed to bump version from ${packageJson2.version}`
@@ -4204,7 +5367,7 @@ async function publishCommand(options) {
       const visibility = result.skill.visibility;
       const visibilityIcon = visibility === "public" ? "\u{1F310}" : "\u{1F512}";
       console.log(
-        `+ @user/${result.skill.username}/${result.skill.name}@${result.version.version}`
+        `+ @${result.skill.namespace ?? "user"}/${result.skill.username}/${result.skill.name}@${result.version.version}`
       );
       console.log(`Checksum: ${result.version.checksum}`);
       console.log(`Visibility: ${visibilityIcon} ${visibility}`);
@@ -4231,17 +5394,17 @@ async function publishCommand(options) {
 init_agents();
 init_config();
 init_lib();
-init_lockfile2();
-init_manifest2();
+init_lockfile3();
+init_manifest3();
 init_symlinks();
 async function remove(nameOrSpecifier) {
   try {
     const manifest = await readManifest();
     const agentConfigs = manifest?.agents;
     const agents = getAvailableAgents(agentConfigs);
-    if (isGitHubSpecifier(nameOrSpecifier)) {
+    if (isGitHubSpecifier2(nameOrSpecifier)) {
       await removeGitHub(nameOrSpecifier, agents, agentConfigs);
-    } else if (nameOrSpecifier.startsWith("@user/")) {
+    } else if (isRegistrySpecifier2(nameOrSpecifier)) {
       await removeRegistry(nameOrSpecifier, agents, agentConfigs);
     } else {
       await removeByShortName(nameOrSpecifier, agents, agentConfigs);
@@ -4253,14 +5416,13 @@ async function remove(nameOrSpecifier) {
   }
 }
 async function removeRegistry(specifier, agents, agentConfigs) {
-  const match = specifier.match(/^@user\/([^/]+)\/([^@/]+)/);
-  if (!match) {
+  const parsed = parseRegistrySpecifier2(specifier);
+  if (!parsed) {
     console.error(`Error: Invalid skill specifier: ${specifier}`);
     process.exit(1);
   }
-  const fullName = `@user/${match[1]}/${match[2]}`;
-  const username = match[1];
-  const name = match[2];
+  const { namespace, owner, name } = parsed;
+  const fullName = `@${namespace}/${owner}/${name}`;
   console.log(`Removing ${fullName}...`);
   const removedFromLockfile = await removeFromLockfile(fullName);
   const removedFromManifest = await removeDependency(fullName);
@@ -4274,7 +5436,7 @@ async function removeRegistry(specifier, agents, agentConfigs) {
     agentConfigs
   });
   const skillsDir = getSkillsDir();
-  const destDir = join(skillsDir, username, name);
+  const destDir = namespace === "org" ? join(skillsDir, "_org", owner, name) : join(skillsDir, owner, name);
   try {
     await rm(destDir, { recursive: true, force: true });
   } catch {
@@ -4282,7 +5444,7 @@ async function removeRegistry(specifier, agents, agentConfigs) {
   console.log(`Removed ${fullName}`);
 }
 async function removeGitHub(specifier, agents, agentConfigs) {
-  const parsed = parseGitHubSpecifier(specifier);
+  const parsed = parseGitHubSpecifier2(specifier);
   if (!parsed) {
     console.error(`Error: Invalid GitHub specifier: ${specifier}`);
     process.exit(1);
@@ -4295,7 +5457,7 @@ async function removeGitHub(specifier, agents, agentConfigs) {
     console.error(`Error: ${lockfileKey} not found in lockfile or pspm.json`);
     process.exit(1);
   }
-  const skillName = getGitHubSkillName(parsed);
+  const skillName = getGitHubSkillName2(parsed);
   await removeAgentSymlinks(skillName, {
     agents,
     projectRoot: process.cwd(),
@@ -4313,8 +5475,8 @@ async function removeGitHub(specifier, agents, agentConfigs) {
 async function removeByShortName(shortName, agents, agentConfigs) {
   const registrySkills = await listLockfileSkills();
   const foundRegistry = registrySkills.find((s) => {
-    const match = s.name.match(/^@user\/([^/]+)\/([^/]+)$/);
-    return match && match[2] === shortName;
+    const parsed = parseRegistrySpecifier2(s.name);
+    return parsed && parsed.name === shortName;
   });
   if (foundRegistry) {
     await removeRegistry(foundRegistry.name, agents, agentConfigs);
@@ -4322,9 +5484,9 @@ async function removeByShortName(shortName, agents, agentConfigs) {
   }
   const githubSkills = await listLockfileGitHubPackages();
   const foundGitHub = githubSkills.find((s) => {
-    const parsed = parseGitHubSpecifier(s.specifier);
+    const parsed = parseGitHubSpecifier2(s.specifier);
     if (!parsed) return false;
-    return getGitHubSkillName(parsed) === shortName;
+    return getGitHubSkillName2(parsed) === shortName;
   });
   if (foundGitHub) {
     await removeGitHub(foundGitHub.specifier, agents, agentConfigs);
@@ -4334,6 +5496,88 @@ async function removeByShortName(shortName, agents, agentConfigs) {
   process.exit(1);
 }
 
+// src/commands/search.ts
+init_api_client();
+init_config();
+init_generated();
+async function search(query, options) {
+  try {
+    const config2 = await resolveConfig();
+    const apiKey = getTokenForRegistry(config2, config2.registryUrl);
+    configure2({ registryUrl: config2.registryUrl, apiKey });
+    const limit = options.limit ?? 20;
+    const sort = options.sort ?? "downloads";
+    if (!options.json) {
+      if (query) {
+        console.log(`Searching for "${query}"...
+`);
+      } else {
+        console.log("Browsing skills...\n");
+      }
+    }
+    const response = await explorePublicSkills({
+      search: query,
+      sort,
+      limit,
+      page: 1
+    });
+    if (response.status !== 200) {
+      console.error("Error: Failed to search skills");
+      process.exit(1);
+    }
+    const { skills, total } = response.data;
+    if (skills.length === 0) {
+      if (query) {
+        console.log(`No skills found matching "${query}".`);
+      } else {
+        console.log("No skills published yet.");
+      }
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    for (const skill of skills) {
+      const name = `@${skill.namespace ?? "user"}/${skill.username}/${skill.name}`;
+      const desc = skill.description ? ` - ${skill.description.slice(0, 80)}${skill.description.length > 80 ? "..." : ""}` : "";
+      const downloads = skill.totalDownloads > 0 ? ` (${formatDownloads(skill.totalDownloads)} downloads)` : "";
+      console.log(`  ${name}${downloads}`);
+      if (desc) {
+        console.log(`    ${desc.trim()}`);
+      }
+    }
+    const showing = Math.min(skills.length, limit);
+    if (total > showing) {
+      console.log(`
+Showing ${showing} of ${total} results.`);
+    } else {
+      console.log(`
+${total} skill(s) found.`);
+    }
+    if (skills.length > 0) {
+      const first = skills[0];
+      console.log(
+        `
+Install with: pspm add @${first.namespace ?? "user"}/${first.username}/${first.name}`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+function formatDownloads(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}k`;
+  }
+  return String(count);
+}
+
 // src/commands/unpublish.ts
 init_api_client();
 init_config();
@@ -4343,14 +5587,19 @@ async function unpublish(specifier, options) {
   try {
     const apiKey = await requireApiKey();
     const registryUrl = await getRegistryUrl();
-    const parsed = parseSkillSpecifier(specifier);
+    const parsed = parseRegistrySpecifier2(specifier);
     if (!parsed) {
       console.error(
-        `Error: Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}[@{version}]`
+        `Error: Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}[@{version}] or @org/{orgname}/{name}[@{version}]`
       );
       process.exit(1);
     }
-    const { username, name, versionRange } = parsed;
+    const { owner, name, versionRange } = parsed;
+    const fullName = generateRegistryIdentifier2({
+      namespace: parsed.namespace,
+      owner,
+      name
+    });
     configure2({ registryUrl, apiKey });
     if (versionRange) {
       console.log(`Unpublishing ${specifier}...`);
@@ -4360,7 +5609,7 @@ async function unpublish(specifier, options) {
         );
         process.exit(1);
       }
-      const response = await deleteSkillVersion(username, name, versionRange);
+      const response = await deleteSkillVersion(owner, name, versionRange);
       if (response.status !== 200) {
         const errorMessage = extractApiErrorMessage(
           response,
@@ -4369,16 +5618,16 @@ async function unpublish(specifier, options) {
         console.error(`Error: ${errorMessage}`);
         process.exit(1);
       }
-      console.log(`Unpublished @user/${username}/${name}@${versionRange}`);
+      console.log(`Unpublished ${fullName}@${versionRange}`);
     } else {
-      console.log(`Unpublishing all versions of @user/${username}/${name}...`);
+      console.log(`Unpublishing all versions of ${fullName}...`);
       if (!options.force) {
         console.error(
           "Warning: This will delete ALL versions. Use --force to confirm."
         );
         process.exit(1);
       }
-      const response = await deleteSkill(username, name);
+      const response = await deleteSkill(owner, name);
       if (response.status !== 200) {
         const errorMessage = extractApiErrorMessage(
           response,
@@ -4387,7 +5636,7 @@ async function unpublish(specifier, options) {
         console.error(`Error: ${errorMessage}`);
         process.exit(1);
       }
-      console.log(`Unpublished @user/${username}/${name} (all versions)`);
+      console.log(`Unpublished ${fullName} (all versions)`);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -4401,7 +5650,7 @@ init_api_client();
 init_config();
 init_errors();
 init_lib();
-init_lockfile2();
+init_lockfile3();
 init_add();
 async function update(options) {
   try {
@@ -4417,11 +5666,13 @@ async function update(options) {
     const updates = [];
     console.log("Checking for updates...\n");
     for (const { name, entry } of skills) {
-      const match = name.match(/^@user\/([^/]+)\/([^/]+)$/);
-      if (!match) continue;
-      const [, username, skillName] = match;
+      const parsed = parseRegistrySpecifier2(name);
+      if (!parsed) continue;
       try {
-        const versionsResponse = await listSkillVersions(username, skillName);
+        const versionsResponse = await listSkillVersions(
+          parsed.owner,
+          parsed.name
+        );
         if (versionsResponse.status !== 200) {
           const errorMessage = extractApiErrorMessage(
             versionsResponse,
@@ -4435,7 +5686,7 @@ async function update(options) {
         const versionStrings = versions.map(
           (v) => v.version
         );
-        const latest = resolveVersion("*", versionStrings);
+        const latest = resolveVersion2("*", versionStrings);
         if (latest && latest !== entry.version) {
           updates.push({
             name,
@@ -4460,11 +5711,10 @@ async function update(options) {
       return;
     }
     console.log("\nUpdating...\n");
-    for (const { name, latest } of updates) {
-      const match = name.match(/^@user\/([^/]+)\/([^/]+)$/);
-      if (!match) continue;
-      const [, username, skillName] = match;
-      const specifier = `@user/${username}/${skillName}@${latest}`;
+    for (const { name: pkgName, latest } of updates) {
+      const parsed = parseRegistrySpecifier2(pkgName);
+      if (!parsed) continue;
+      const specifier = `${pkgName}@${latest}`;
       await add([specifier], {});
     }
     console.log("\nAll skills updated.");
@@ -4479,12 +5729,12 @@ async function upgrade() {
   try {
     const currentVersion = getCurrentVersion();
     console.log("Checking for updates...\n");
-    const latestVersion = getLatestVersion3(packageName);
+    const latestVersion = getLatestVersion4(packageName);
     if (!latestVersion) {
       console.error("Error: Could not fetch latest version from registry.");
       process.exit(1);
     }
-    if (currentVersion === latestVersion) {
+    if (semver2.valid(currentVersion) && semver2.valid(latestVersion) && !semver2.gt(latestVersion, currentVersion)) {
       console.log(`Already on the latest version: ${currentVersion}`);
       return;
     }
@@ -4517,7 +5767,7 @@ function getCurrentVersion() {
     return "unknown";
   }
 }
-function getLatestVersion3(packageName) {
+function getLatestVersion4(packageName) {
   try {
     const output = execSync(`npm view ${packageName} version`, {
       encoding: "utf-8",
@@ -4569,7 +5819,7 @@ function getInstallCommand(pm, packageName, version3) {
 }
 
 // src/commands/version.ts
-init_manifest2();
+init_manifest3();
 async function version(bump, options = {}) {
   try {
     const manifest = await readManifest();
@@ -4585,7 +5835,7 @@ async function version(bump, options = {}) {
       );
       process.exit(1);
     }
-    if (!semver__default.valid(manifest.version)) {
+    if (!semver2__default.valid(manifest.version)) {
       console.error(
         `Error: Current version "${manifest.version}" is not valid semver.`
       );
@@ -4594,7 +5844,7 @@ async function version(bump, options = {}) {
       );
       process.exit(1);
     }
-    const newVersion = semver__default.inc(manifest.version, bump);
+    const newVersion = semver2__default.inc(manifest.version, bump);
     if (!newVersion) {
       console.error(`Error: Failed to bump version from ${manifest.version}`);
       process.exit(1);
@@ -4640,6 +5890,9 @@ async function whoami() {
     process.exit(1);
   }
 }
+
+// src/update-notifier.ts
+init_version2();
 var PACKAGE_NAME = "@anytio/pspm";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CACHE_DIR = join(homedir(), ".pspm");
@@ -4648,7 +5901,7 @@ async function checkForUpdates(currentVersion) {
   try {
     const cache = await readCache();
     if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
-      if (cache.latestVersion !== currentVersion) {
+      if (isNewerVersion2(cache.latestVersion, currentVersion)) {
         printUpdateWarning(currentVersion, cache.latestVersion);
       }
       return;
@@ -4683,7 +5936,7 @@ function fetchAndCache(currentVersion) {
     };
     writeCache(cache).catch(() => {
     });
-    if (latestVersion !== currentVersion) {
+    if (isNewerVersion2(latestVersion, currentVersion)) {
       printUpdateWarning(currentVersion, latestVersion);
     }
   } catch {
@@ -4705,7 +5958,7 @@ var packageJson = JSON.parse(
 );
 var version2 = packageJson.version;
 var program = new Command();
-program.name("pspm").description("Prompt Skill Package Manager for AI coding agents").version(version2);
+program.name("pspm").description("Package manager for AI agent skills").version(version2);
 var configCmd = program.command("config").description("Manage PSPM configuration");
 configCmd.command("show").description("Show resolved configuration").action(async () => {
   await configShow();
@@ -4745,45 +5998,64 @@ program.command("migrate").description(
   await migrate({ dryRun: options.dryRun });
 });
 program.command("add <specifiers...>").description(
-  "Add one or more skills (e.g., @user/bsheng/vite_slides@^2.0.0 or github:owner/repo/path@ref)"
+  "Add skills from registry, GitHub, local paths, or well-known URLs"
 ).option("--save", "Save to lockfile (default)").option(
   "--agent <agents>",
   'Comma-separated agents for symlinks (default: all agents, use "none" to skip)'
-).option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
+).option("-g, --global", "Install to user home directory instead of project").option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
   await add(specifiers, {
     save: options.save ?? true,
     agent: options.agent,
-    yes: options.yes
+    yes: options.yes,
+    global: options.global
   });
 });
 program.command("remove <name>").alias("rm").description("Remove an installed skill").action(async (name) => {
   await remove(name);
 });
-program.command("list").alias("ls").description("List installed skills").option("--json", "Output as JSON").action(async (options) => {
-  await list({ json: options.json });
+program.command("list").alias("ls").description("List installed skills").option("--json", "Output as JSON").option("-g, --global", "List globally installed skills").action(async (options) => {
+  await list({ json: options.json, global: options.global });
 });
 program.command("install [specifiers...]").alias("i").description(
   "Install skills from lockfile, or add and install specific packages"
 ).option("--frozen-lockfile", "Fail if lockfile is missing or outdated").option("--dir <path>", "Install skills to a specific directory").option(
   "--agent <agents>",
   'Comma-separated agents for symlinks (default: all agents, use "none" to skip)'
-).option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
+).option("-g, --global", "Install to user home directory instead of project").option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
   await install(specifiers, {
     frozenLockfile: options.frozenLockfile,
     dir: options.dir,
     agent: options.agent,
-    yes: options.yes
+    yes: options.yes,
+    global: options.global
   });
 });
 program.command("link").description("Recreate agent symlinks without reinstalling").option(
   "--agent <agents>",
   'Comma-separated agents for symlinks (default: all agents, use "none" to skip)'
-).option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (options) => {
-  await link({ agent: options.agent, yes: options.yes });
+).option("-g, --global", "Recreate global agent symlinks").option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (options) => {
+  await link({
+    agent: options.agent,
+    yes: options.yes,
+    global: options.global
+  });
 });
 program.command("update").description("Update all skills to latest compatible versions").option("--dry-run", "Show what would be updated without making changes").action(async (options) => {
   await update({ dryRun: options.dryRun });
 });
+program.command("search [query]").alias("find").description("Search and discover skills from the registry").option(
+  "-s, --sort <sort>",
+  "Sort by: downloads, recent, name (default: downloads)"
+).option("-l, --limit <n>", "Maximum results (default: 20)", Number.parseInt).option("--json", "Output as JSON").action(async (query, options) => {
+  await search(query, {
+    sort: options.sort,
+    limit: options.limit,
+    json: options.json
+  });
+});
+program.command("audit").description("Verify integrity of installed skills and check for issues").option("--json", "Output as JSON").action(async (options) => {
+  await audit({ json: options.json });
+});
 program.command("outdated [packages...]").description("Check for outdated skills").option("--json", "Output as JSON").option("--all", "Include up-to-date packages").action(async (packages, options) => {
   await outdated(packages, { json: options.json, all: options.all });
 });
@@ -4830,6 +6102,9 @@ program.command("deprecate <specifier> [message]").description(
   await deprecate(specifier, message, { undo: options.undo });
 });
 await program.parseAsync();
-await checkForUpdates(version2);
+var executedCommand = program.args[0];
+if (executedCommand !== "upgrade") {
+  await checkForUpdates(version2);
+}
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map