@wrongstack/core 0.277.1 → 0.280.0

package/dist/skills/index.js

@@ -1,37 +1,168 @@
-import * as fs4 from 'fs/promises';
-import * as path4 from 'path';
+import * as fs5 from 'fs/promises';
 import * as os from 'os';
-import { createGunzip } from 'zlib';
+import * as path5 from 'path';
 import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
+import { createGunzip } from 'zlib';
 import { randomBytes } from 'crypto';
+import { spawn } from 'child_process';
 
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
+// src/skills/foreign-sources.ts
+var FOREIGN_SKILL_TOOLS = [
+  { id: "agents", subdir: "skills" },
+  // shared store (asm / agentskills.io ecosystem)
+  { id: "codex", subdir: "skills" },
+  // OpenAI Codex CLI
+  { id: "gemini", subdir: "skills" },
+  // Gemini CLI
+  { id: "cursor", subdir: "skills" },
+  // Cursor (standard subdir, aligned with skills.sh ecosystem)
+  { id: "qwen", subdir: "skills" },
+  // Qwen Code
+  { id: "trae", subdir: "skills" },
+  // Trae
+  { id: "windsurf", subdir: "skills" }
+  // Windsurf
+];
+var KNOWN_FOREIGN_IDS = new Set(FOREIGN_SKILL_TOOLS.map((t) => t.id));
+function resolveForeignToolIds(opt) {
+  return resolveForeignToolIdsWithWarnings(opt).ids;
+}
+function resolveForeignToolIdsWithWarnings(opt) {
+  if (opt === false) return { ids: [], unknownIds: [] };
+  if (Array.isArray(opt)) {
+    const ids = [];
+    const unknownIds = [];
+    for (const id of opt) {
+      if (KNOWN_FOREIGN_IDS.has(id)) ids.push(id);
+      else unknownIds.push(id);
+    }
+    return { ids, unknownIds };
   }
-  return value;
+  return { ids: FOREIGN_SKILL_TOOLS.map((t) => t.id), unknownIds: [] };
+}
+function securityScoreToTier(score) {
+  if (score == null || Number.isNaN(score)) return "low";
+  if (score < 30) return "low";
+  if (score < 70) return "medium";
+  return "high";
 }
 
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+// src/skills/frontmatter.ts
+var SCALAR_KEYS = /* @__PURE__ */ new Set(["name", "description", "version", "license", "compatibility"]);
+function parseSkillFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return {};
+  return parseFrontmatterBlock(text.slice(4, end));
+}
+function stripFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return text;
+  let body = text.slice(end + 4);
+  if (body.startsWith("\n")) body = body.slice(1);
+  return body;
+}
+function normalizeLineEndings(s) {
+  return s.replace(/\r\n?/g, "\n");
+}
+function parseFrontmatterBlock(block) {
+  const out = {};
+  const lines = block.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const m = /^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const key = m[1] ?? "";
+    const rest = (m[2] ?? "").trim();
+    if (key === "metadata") {
+      const map = {};
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        const sm = /^\s+([a-zA-Z0-9_.-]+):\s*(.*)$/.exec(sub);
+        if (!sm) break;
+        map[sm[1] ?? ""] = unquote((sm[2] ?? "").trim());
+        i++;
+      }
+      if (Object.keys(map).length > 0) out.metadata = map;
+      continue;
+    }
+    if (rest === "|" || rest === ">") {
+      const collected = [];
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        if (sub === "" || sub.startsWith(" ") || sub.startsWith("	")) {
+          collected.push(sub.replace(/^\s+/, ""));
+          i++;
+        } else break;
+      }
+      out[normalizeKey(key)] = collected.join("\n").trim();
+      continue;
+    }
+    if (key === "allowed-tools" || key === "allowedTools") {
+      out.allowedTools = rest.split(/[\s,]+/).filter(Boolean);
+      i++;
+      continue;
+    }
+    if (SCALAR_KEYS.has(key)) {
+      out[key] = unquote(rest);
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return out;
+}
+function normalizeKey(key) {
+  return key === "allowed-tools" ? "allowedTools" : key;
+}
+function unquote(s) {
+  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function isValidSkillNameFormat(name) {
+  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+function validateSkillName(name, parentDirName) {
+  const errors = [];
+  if (!name || name.trim().length === 0) {
+    errors.push("name is empty");
+    return errors;
+  }
+  if (name.length > 64) errors.push(`name is ${name.length} characters (max 64)`);
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    errors.push(
+      "name must be lowercase letters, digits, and single hyphens only (no leading/trailing/consecutive hyphens)"
+    );
+  }
+  if (parentDirName !== void 0 && name !== parentDirName) {
+    errors.push(`name "${name}" must match its parent directory "${parentDirName}"`);
+  }
+  return errors;
 }
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path4.dirname(targetPath);
-  await fs4.mkdir(dir, { recursive: true });
-  const tmp = path4.join(dir, `.${path4.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const dir = path5.dirname(targetPath);
+  await fs5.mkdir(dir, { recursive: true });
+  const tmp = path5.join(dir, `.${path5.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fs4.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fs5.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fs4.writeFile(tmp, content, { flag: "wx" });
+      await fs5.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fs4.open(tmp, "r+");
+      const fh = await fs5.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -41,24 +172,24 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat3 = await fs4.stat(targetPath);
+      const stat3 = await fs5.stat(targetPath);
       mode = stat3.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fs4.chmod(tmp, mode);
+      await fs5.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fs4.chmod(targetPath, mode);
+        await fs5.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fs4.unlink(tmp);
+      await fs5.unlink(tmp);
     } catch {
     }
     throw err;
@@ -67,14 +198,14 @@ async function atomicWrite(targetPath, content, opts = {}) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fs4.rename(from, to);
+    await fs5.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fs4.rename(from, to);
+      await fs5.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -88,6 +219,21 @@ async function renameWithRetry(from, to) {
   throw lastErr;
 }
 
+// src/utils/error.ts
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
 // src/types/errors.ts
 var ERROR_CODES = {
   // Provider
@@ -189,6 +335,118 @@ var FsError = class extends WrongStackError {
     this.path = opts.path;
   }
 };
+var FetchError = class extends WrongStackError {
+  status;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      severity: "error",
+      recoverable: opts.status === 429 || opts.status >= 500,
+      context: { status: opts.status, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FetchError";
+    this.status = opts.status;
+  }
+};
+var ParseError = class extends WrongStackError {
+  source;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.PARSE_FAILED,
+      subsystem: "general",
+      severity: "error",
+      recoverable: false,
+      context: { source: opts.source, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ParseError";
+    this.source = opts.source;
+  }
+};
+
+// src/skills/limits.ts
+var SKILL_LIMITS = {
+  /**
+   * Per-skill body cap when injecting a full skill body into the system prompt
+   * (eager mode), and when returning a skill body from the `skill` tool.
+   * ~4k tokens. Oversized bodies are truncated at a paragraph boundary.
+   *
+   * Consumers: `system-prompt-builder.capSkillBody`, `skill` tool body return.
+   */
+  MAX_SKILL_BODY_CHARS: 16e3,
+  /**
+   * Per-resource cap when the `skill` tool loads a bundled file
+   * (`scripts/`, `references/`, `assets/`). ~8k tokens.
+   *
+   * Consumer: `skill` tool `loadResource`.
+   */
+  MAX_RESOURCE_CHARS: 32e3,
+  /**
+   * Maximum number of bundled resource paths the `skill` tool lists in one
+   * response. Caps a pathological skill (huge `assets/` tree) from blowing up
+   * the tool result.
+   *
+   * Consumer: `skill` tool resource listing.
+   */
+  MAX_LISTED_RESOURCES: 100,
+  /**
+   * Max size of a single installed skill file (SKILL.md or a bundled resource).
+   * Guards against a malicious registry skill shipping a multi-MB blob that
+   * then flows into the prompt. 100KB.
+   *
+   * Consumer: `SkillInstaller.install` / `importFromDir`.
+   */
+  MAX_SKILL_FILE_SIZE: 100 * 1024,
+  /**
+   * Max size of a GitHub tarball downloaded by the skill installer. Guards
+   * against a repo accidentally (or maliciously) shipping a giant tarball that
+   * would be extracted into a temp dir. 50MB.
+   *
+   * Consumer: `downloadGitHubTarball`.
+   */
+  MAX_TARBALL_SIZE: 50 * 1024 * 1024,
+  /**
+   * Default total char budget for skill bodies injected in eager mode when
+   * `config.skills.eagerMaxChars` is unset. ~6k tokens. Skills are injected
+   * highest-priority first; once the budget is exhausted the remaining skills
+   * are listed as a manifest the agent loads via the `skill` tool. Set very
+   * high to effectively disable budgeting.
+   *
+   * Consumer: `DefaultSystemPromptBuilder.buildMemoryAndSkills` (default for
+   * `skillEagerMaxChars`).
+   */
+  EAGER_DEFAULT_MAX_CHARS: 24e3,
+  /**
+   * Auto-compact body limits (the token-saving fallback used when a skill has
+   * no hand-crafted `SKILL.save.md`). The Overview and Rules sections are
+   * extracted and trimmed to these char budgets, then the total is capped.
+   *
+   * Consumer: `DefaultSkillLoader.compactSkillBody`.
+   */
+  COMPACT_OVERVIEW_MAX: 200,
+  COMPACT_RULES_MAX: 350,
+  COMPACT_TOTAL_MAX: 450,
+  /**
+   * Max length of a skill name (agentskills.io spec). Enforced by the
+   * frontmatter validator's format regex plus this length bound.
+   *
+   * Consumer: `isValidSkillNameFormat`.
+   */
+  SKILL_NAME_MAX_LEN: 64,
+  /**
+   * Soft line limit for a SKILL.md body, per the bundled `skill-creator` rule.
+   * Not enforced in code (a skill can exceed it) — surfaced by `/skill-gen
+   * validate` and the `skill-creator` skill as guidance to move deep material
+   * into `references/`.
+   *
+   * Consumer: `skill-creator` skill, `/skill-gen validate` advisory.
+   */
+  SKILL_BODY_LINE_LIMIT: 500
+};
 
 // src/skills/github-fetcher.ts
 function parseSkillRef(input) {
@@ -214,32 +472,58 @@ function parseSkillRef(input) {
   }
   return { owner: expectDefined(parts[0]), repo: expectDefined(parts[1]), ref };
 }
-var MAX_TARBALL_SIZE = 50 * 1024 * 1024;
+function resolveGitHubToken(env = process.env) {
+  const raw = env["WRONGSTACK_GITHUB_TOKEN"] ?? env["GITHUB_TOKEN"] ?? env["GH_TOKEN"];
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 async function downloadGitHubTarball(parsed) {
   const url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/tarball/${parsed.ref}`;
-  const response = await fetch(url, {
-    signal: AbortSignal.timeout(3e4),
-    headers: {
-      Accept: "application/vnd.github+json",
-      "User-Agent": "wrongstack-skill-installer"
-    },
-    redirect: "follow"
-  });
+  const token = resolveGitHubToken();
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": "wrongstack-skill-installer"
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      signal: AbortSignal.timeout(3e4),
+      headers,
+      redirect: "follow"
+    });
+  } catch (err) {
+    throw new FetchError({
+      message: `Network error fetching ${parsed.owner}/${parsed.repo}: ${err instanceof Error ? err.message : String(err)}`,
+      status: 0,
+      context: { owner: parsed.owner, repo: parsed.repo, ref: parsed.ref, op: "tarball" },
+      cause: err
+    });
+  }
   if (!response.ok) {
     if (response.status === 404) {
       throw new WrongStackError({
-        message: `Repository not found: ${parsed.owner}/${parsed.repo}` + (parsed.ref !== "main" ? ` (ref: ${parsed.ref})` : ""),
+        message: `Repository not found: ${parsed.owner}/${parsed.repo}` + (parsed.ref !== "main" ? ` (ref: ${parsed.ref})` : "") + (token ? "" : ". If this is a private repo, set GITHUB_TOKEN (or GH_TOKEN)."),
         code: ERROR_CODES.UNKNOWN,
         subsystem: "general",
         context: { owner: parsed.owner, repo: parsed.repo, ref: parsed.ref, status: 404 }
       });
     }
     if (response.status === 403) {
+      const remaining = response.headers.get("x-ratelimit-remaining");
+      const isRateLimited = remaining === "0";
       throw new WrongStackError({
-        message: `Access denied: ${parsed.owner}/${parsed.repo}. The repository may be private or rate-limited.`,
+        message: isRateLimited ? `GitHub API rate limit exceeded. Set GITHUB_TOKEN (or GH_TOKEN) to use the higher authenticated limit.` : `Access denied: ${parsed.owner}/${parsed.repo}. The repository may be private (set GITHUB_TOKEN to install private repos) or rate-limited.`,
         code: ERROR_CODES.UNKNOWN,
         subsystem: "general",
-        context: { owner: parsed.owner, repo: parsed.repo, status: 403 }
+        context: {
+          owner: parsed.owner,
+          repo: parsed.repo,
+          status: 403,
+          rateLimited: isRateLimited,
+          hasToken: Boolean(token)
+        }
       });
     }
     throw new WrongStackError({
@@ -250,20 +534,20 @@ async function downloadGitHubTarball(parsed) {
     });
   }
   const contentLength = response.headers.get("content-length");
-  if (contentLength && Number.parseInt(contentLength, 10) > MAX_TARBALL_SIZE) {
+  if (contentLength && Number.parseInt(contentLength, 10) > SKILL_LIMITS.MAX_TARBALL_SIZE) {
     throw new WrongStackError({
-      message: `Tarball too large (${(Number.parseInt(contentLength, 10) / 1024 / 1024).toFixed(1)}MB). Max: ${MAX_TARBALL_SIZE / 1024 / 1024}MB`,
+      message: `Tarball too large (${(Number.parseInt(contentLength, 10) / 1024 / 1024).toFixed(1)}MB). Max: ${SKILL_LIMITS.MAX_TARBALL_SIZE / 1024 / 1024}MB`,
       code: ERROR_CODES.UNKNOWN,
       subsystem: "general",
       context: {
         owner: parsed.owner,
         repo: parsed.repo,
         contentLengthBytes: Number.parseInt(contentLength, 10),
-        maxBytes: MAX_TARBALL_SIZE
+        maxBytes: SKILL_LIMITS.MAX_TARBALL_SIZE
       }
     });
   }
-  const tempDir = await fs4.mkdtemp(path4.join(os.tmpdir(), "wskill-"));
+  const tempDir = await fs5.mkdtemp(path5.join(os.tmpdir(), "wskill-"));
   try {
     if (!response.body) {
       throw new WrongStackError({
@@ -285,7 +569,7 @@ async function downloadGitHubTarball(parsed) {
     await extractTar(tarBuf, tempDir);
     return { tempDir };
   } catch (err) {
-    await fs4.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    await fs5.rm(tempDir, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   }
@@ -302,25 +586,25 @@ async function extractTar(buf, destDir) {
     const fullPath = prefix ? `${prefix}/${name}` : name;
     const relPath = stripTopDir(fullPath);
     if (relPath && relPath !== "." && relPath !== "..") {
-      const destPath = path4.join(destDir, relPath);
-      const resolvedDest = path4.resolve(destPath);
-      const resolvedRoot = path4.resolve(destDir);
-      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path4.sep)) {
+      const destPath = path5.join(destDir, relPath);
+      const resolvedDest = path5.resolve(destPath);
+      const resolvedRoot = path5.resolve(destDir);
+      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path5.sep)) {
         offset += 512 + Math.ceil(size / 512) * 512;
         continue;
       }
       if (typeflag === 53 || typeflag === 0) {
         if (relPath.endsWith("/") || typeflag === 53) {
-          await fs4.mkdir(destPath, { recursive: true });
+          await fs5.mkdir(destPath, { recursive: true });
         }
       }
       if ((typeflag === 48 || typeflag === 0 || typeflag === 0) && size > 0) {
-        const dir = path4.dirname(destPath);
-        await fs4.mkdir(dir, { recursive: true });
+        const dir = path5.dirname(destPath);
+        await fs5.mkdir(dir, { recursive: true });
         const dataStart = offset + 512;
         const dataEnd = dataStart + size;
         if (dataEnd > buf.length) break;
-        await fs4.writeFile(destPath, buf.subarray(dataStart, dataEnd));
+        await fs5.writeFile(destPath, buf.subarray(dataStart, dataEnd));
       }
     }
     offset += 512 + Math.ceil(size / 512) * 512;
@@ -347,7 +631,7 @@ var SkillManifestStore = class {
   async read() {
     if (this.cache) return this.cache;
     try {
-      const raw = await fs4.readFile(this.manifestPath, "utf8");
+      const raw = await fs5.readFile(this.manifestPath, "utf8");
       const data = JSON.parse(raw);
       if (!Array.isArray(data.skills)) {
         this.cache = { skills: [] };
@@ -360,25 +644,21 @@ var SkillManifestStore = class {
     return this.cache;
   }
   async write(data) {
-    const dir = path4.dirname(this.manifestPath);
-    await fs4.mkdir(dir, { recursive: true });
+    const dir = path5.dirname(this.manifestPath);
+    await fs5.mkdir(dir, { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2) + "\n");
     this.cache = data;
   }
   async addEntry(entry) {
     const data = await this.read();
-    data.skills = data.skills.filter(
-      (s) => !(s.name === entry.name && s.scope === entry.scope)
-    );
+    data.skills = data.skills.filter((s) => !(s.name === entry.name && s.scope === entry.scope));
     data.skills.push(entry);
     await this.write(data);
   }
   async removeEntry(name, scope) {
     const data = await this.read();
     const before = data.skills.length;
-    data.skills = data.skills.filter(
-      (s) => !(s.name === name && s.scope === scope)
-    );
+    data.skills = data.skills.filter((s) => !(s.name === name && s.scope === scope));
     if (data.skills.length === before) return false;
     await this.write(data);
     return true;
@@ -401,25 +681,363 @@ var SkillManifestStore = class {
   }
 };
 
-// src/skills/skill-installer.ts
-var MAX_SKILL_FILE_SIZE = 100 * 1024;
+// src/skills/registry/github-direct-adapter.ts
+var githubDirectAdapter = {
+  id: "github",
+  displayName: "GitHub (direct)",
+  async search(_query, _opts = {}) {
+    return { adapterId: "github", results: [], hasMore: false };
+  },
+  resolveInstallRef(registryId) {
+    const trimmed = registryId.trim();
+    if (!trimmed.includes("/")) {
+      return trimmed;
+    }
+    return trimmed;
+  }
+};
+
+// src/skills/registry/skills-sh-adapter.ts
+var DEFAULT_SKILLS_SH_URL = "https://skills.sh";
+var SEARCH_TIMEOUT_MS = 15e3;
+var MAX_PAGE_SIZE = 50;
+var defaultFetcher = async (url) => {
+  let res;
+  try {
+    res = await fetch(url, {
+      signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS),
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "wrongstack-skill-installer"
+      },
+      redirect: "follow"
+    });
+  } catch (err) {
+    throw new FetchError({
+      message: `Network error querying skill registry: ${err instanceof Error ? err.message : String(err)}`,
+      status: 0,
+      context: { url, op: "skills.sh.search" },
+      cause: err
+    });
+  }
+  if (!res.ok) {
+    throw new FetchError({
+      message: `Skill registry returned ${res.status} ${res.statusText}`,
+      status: res.status,
+      context: { url, op: "skills.sh.search" }
+    });
+  }
+  try {
+    return await res.json();
+  } catch (err) {
+    throw new ParseError({
+      message: `Skill registry response was not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+      source: "skills.sh.search",
+      context: { url },
+      cause: err
+    });
+  }
+};
+function createSkillsShAdapter(opts = {}) {
+  const baseUrl = (opts.baseUrl ?? DEFAULT_SKILLS_SH_URL).replace(/\/+$/, "");
+  const fetcher = opts.fetcher ?? defaultFetcher;
+  const id = "skills.sh";
+  return {
+    id,
+    displayName: "skills.sh",
+    async search(query, sopts = {}) {
+      const page = Math.max(1, sopts.page ?? 1);
+      const pageSize = Math.min(MAX_PAGE_SIZE, Math.max(1, sopts.pageSize ?? 20));
+      const q = query.trim();
+      if (!q) return { adapterId: id, results: [], hasMore: false };
+      const url = `${baseUrl}/api/skills?query=${encodeURIComponent(q)}&page=${page}&pageSize=${pageSize}&sortBy=installs`;
+      const raw = await fetcher(url);
+      const results = parseResults(raw, url);
+      return {
+        adapterId: id,
+        results,
+        hasMore: results.length === pageSize
+      };
+    },
+    resolveInstallRef(registryId) {
+      const trimmed = registryId.trim();
+      if (!trimmed) {
+        throw new ParseError({
+          message: "Empty skills.sh registry id.",
+          source: "skills.sh.resolveInstallRef"
+        });
+      }
+      const atIdx = trimmed.indexOf("@");
+      const repoPart = atIdx > 0 ? trimmed.slice(0, atIdx) : trimmed;
+      const segs = repoPart.split("/").filter(Boolean);
+      if (segs.length !== 2) {
+        throw new ParseError({
+          message: `Invalid skills.sh id "${registryId}". Expected "<owner>/<repo>" or "<owner>/<repo>@<ref>".`,
+          source: "skills.sh.resolveInstallRef",
+          context: { registryId }
+        });
+      }
+      return trimmed;
+    }
+  };
+}
+function parseResults(raw, url) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new ParseError({
+      message: "Skill registry response was not a JSON object.",
+      source: "skills.sh.search",
+      context: { url }
+    });
+  }
+  const results = raw.results;
+  if (!Array.isArray(results)) {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < results.length; i++) {
+    const entry = results[i];
+    if (!entry || typeof entry !== "object") continue;
+    const name = strField(entry, "name") ?? strField(entry, "slug");
+    const description = strField(entry, "description") ?? "";
+    const owner = strField(entry, "owner") ?? strField(entry, "author");
+    const repo = strField(entry, "repo") ?? strField(entry, "repository");
+    if (!name || !owner || !repo) continue;
+    const ref = strField(entry, "ref") ?? strField(entry, "branch") ?? strField(entry, "tag");
+    const installRef = ref ? `${owner}/${repo}@${ref}` : `${owner}/${repo}`;
+    out.push({
+      id: strField(entry, "id") ?? `${owner}/${repo}`,
+      name,
+      description,
+      author: owner,
+      installs: numField(entry, "installs") ?? numField(entry, "installCount"),
+      stars: numField(entry, "stars") ?? numField(entry, "starCount"),
+      securityScore: numField(entry, "securityScore") ?? numField(entry, "score"),
+      updatedAt: strField(entry, "updatedAt") ?? strField(entry, "updated_at"),
+      installRef
+    });
+  }
+  return out;
+}
+function strField(rec, key) {
+  const v = rec[key];
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function numField(rec, key) {
+  const v = rec[key];
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && /^\d+(\.\d+)?$/.test(v.trim())) {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+async function validateSkillNameAvailable(name, loader) {
+  const formatViolations = validateSkillName(name);
+  const conflicts = loader ? (await loader.listEntries()).filter((e) => e.name === name) : [];
+  const formatOk = formatViolations.length === 0;
+  const collisionBlocks = conflicts.some((c) => c.source === "project" || c.source === "user");
+  return {
+    ok: formatOk && !collisionBlocks,
+    formatViolations,
+    conflicts
+  };
+}
+function generateSkillSkeleton(opts) {
+  const name = opts.name.trim();
+  if (!isValidSkillNameFormat(name)) {
+    throw new WrongStackError({
+      message: `Cannot generate skeleton: invalid skill name "${name}". Names must be kebab-case (a-z0-9 and hyphens), \u226464 chars.`,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      context: { name }
+    });
+  }
+  const description = opts.description.trim();
+  const triggers = (opts.triggerKeywords ?? []).map((k) => k.trim()).filter(Boolean).map((k) => `"${k}"`).join(", ");
+  const triggerLine = triggers ? `
+  Triggers: user says ${triggers}.` : "";
+  const version = opts.version?.trim() || "1.0.0";
+  const title = name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  return `---
+name: ${name}
+description: |
+  ${description || `Use this skill when <trigger situation>.`}${triggerLine}
+version: ${version}
+---
+
+# ${title}
+
+## Overview
+
+${description || "One-line description of what this skill does."}
+
+## Rules
+
+1. Rule one
+2. Rule two
+
+## Patterns
+
+### Do
+
+\`\`\`ts
+// good example
+\`\`\`
+
+### Don't
+
+\`\`\`ts
+// bad example
+\`\`\`
+
+## Skills in scope
+
+- \`other-skill\` \u2014 for delegation when this skill needs help
+`;
+}
+function extractSkillFromPrompt(prompt) {
+  const text = prompt.trim();
+  if (!text) {
+    return { suggestedName: "", description: "", body: "", triggerKeywords: [] };
+  }
+  const headingMatch = text.match(/^#{1,6}\s+(.+?)\s*$/m);
+  const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim() ?? text;
+  const titleSource = headingMatch?.[1] ?? firstLine.replace(/^#+\s*/, "");
+  const suggestedName = toKebab(titleSource).slice(0, SKILL_LIMITS.SKILL_NAME_MAX_LEN);
+  const paragraphs = text.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
+  const description = paragraphs[0]?.replace(/^#{1,6}\s+/m, "").trim() ?? titleSource;
+  const body = paragraphs.slice(1).join("\n\n");
+  const quoted = [...text.matchAll(/"([^"]{2,40})"/g)].map((m) => m[1]).filter((q) => typeof q === "string").map((q) => q.toLowerCase());
+  const titleWords = titleSource.split(/\W+/).map((w) => w.toLowerCase()).filter((w) => w.length > 3 && !STOPWORDS.has(w));
+  const triggerKeywords = dedupe([...quoted, ...titleWords]).slice(0, 8);
+  return { suggestedName, description, body, triggerKeywords };
+}
+async function openInEditor(filePath, env = process.env) {
+  const editor = env["VISUAL"]?.trim() && env["VISUAL"] || env["EDITOR"]?.trim() && env["EDITOR"] || defaultEditor();
+  if (!editor) {
+    throw new WrongStackError({
+      message: "No editor found. Set the EDITOR or VISUAL environment variable (e.g. `export EDITOR=code` or `export EDITOR=vim`).",
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      context: { filePath }
+    });
+  }
+  const shell = process.platform === "win32";
+  const parts = editor.split(/\s+/).filter(Boolean);
+  if (parts.length === 0) {
+    throw new WrongStackError({
+      message: "Resolved editor command is empty.",
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      context: { filePath }
+    });
+  }
+  const child = spawn(parts[0], [...parts.slice(1), filePath], {
+    stdio: "ignore",
+    detached: true,
+    shell
+  });
+  child.unref();
+}
+async function writeSkeletonSkill(skillsDir, body, opts = {}) {
+  const fm = parseSkillFrontmatter(body);
+  const name = fm.name;
+  if (!name || !isValidSkillNameFormat(name)) {
+    throw new WrongStackError({
+      message: "Skeleton body has no valid `name` in its frontmatter.",
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general"
+    });
+  }
+  const skillDir = path5.join(skillsDir, name);
+  const skillFile = path5.join(skillDir, "SKILL.md");
+  if (!opts.overwrite) {
+    try {
+      await fs5.access(skillFile);
+      throw new WrongStackError({
+        message: `A skill already exists at ${skillFile}. Use --force to overwrite.`,
+        code: ERROR_CODES.VALIDATION_ERROR,
+        subsystem: "general",
+        context: { skillFile }
+      });
+    } catch (err) {
+      if (err instanceof WrongStackError) throw err;
+    }
+  }
+  await fs5.mkdir(skillDir, { recursive: true });
+  await fs5.writeFile(skillFile, body, "utf8");
+  return skillFile;
+}
+function bodyLineAdvisory(body) {
+  const lines = body.split("\n").length;
+  return { lines, over: lines > SKILL_LIMITS.SKILL_BODY_LINE_LIMIT };
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "your",
+  "have",
+  "will",
+  "are",
+  "was",
+  "were",
+  "been",
+  "into",
+  "when",
+  "use",
+  "skill",
+  "about"
+]);
+function toKebab(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, SKILL_LIMITS.SKILL_NAME_MAX_LEN) || "skill";
+}
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+function defaultEditor() {
+  if (process.platform === "win32") return "notepad";
+  if (process.platform === "darwin") return "open";
+  return void 0;
+}
+var MAX_SKILL_FILE_SIZE = SKILL_LIMITS.MAX_SKILL_FILE_SIZE;
 var SkillInstaller = class {
   opts;
   manifest;
+  adapters;
   constructor(opts) {
     this.opts = opts;
     this.manifest = new SkillManifestStore(opts.manifestPath);
+    this.adapters = opts.registryAdapters?.length ? opts.registryAdapters : [githubDirectAdapter];
   }
   /**
-   * Install skills from a GitHub repository.
-   * Supports both single-skill repos (SKILL.md at root) and multi-skill repos (skills/ subdirectory).
+   * Install skills from a skill reference.
+   *
+   * Accepts two ref formats:
+   *   - `user/repo[@ref]`               — direct GitHub install (original path)
+   *   - `<adapterId>:<registryId>`      — registry-resolved (e.g.
+   *                                       `skills.sh:owner/repo@v1`); the
+   *                                       adapter resolves it to a `user/repo`
+   *                                       ref and the install proceeds as above.
+   *
+   * Supports both single-skill repos (SKILL.md at root) and multi-skill repos
+   * (skills/ subdirectory). The manifest records the GitHub source as
+   * `github:owner/repo` (so `/skill-update` keeps working) plus the originating
+   * registry in `registryFrom` when the install came through a registry.
    */
   async install(refInput, opts) {
-    const parsed = parseSkillRef(refInput);
+    const resolved = this.resolveRef(refInput);
+    const parsed = parseSkillRef(resolved.installRef);
     const scope = opts?.global ? "user" : "project";
     const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
     const source = `github:${parsed.owner}/${parsed.repo}`;
-    this.opts.log?.(`Downloading ${parsed.owner}/${parsed.repo}@${parsed.ref}...`);
+    this.opts.log?.(
+      resolved.fromRegistry ? `Resolving ${refInput} \u2192 ${resolved.installRef} (${resolved.adapterId}), downloading...` : `Downloading ${parsed.owner}/${parsed.repo}@${parsed.ref}...`
+    );
     const { tempDir } = await downloadGitHubTarball(parsed);
     try {
       const skills = await this.detectSkills(tempDir);
@@ -439,14 +1057,14 @@ var SkillInstaller = class {
           this.opts.log?.(`Overwriting existing skill "${skill.name}" (${scope})...`);
           await this.removeSkillFiles(skill.name, scope);
         }
-        const destDir = path4.join(targetDir, skill.name);
-        await fs4.mkdir(destDir, { recursive: true });
+        const destDir = path5.join(targetDir, skill.name);
+        await fs5.mkdir(destDir, { recursive: true });
         const copiedFiles = [];
         for (const file of skill.files) {
-          const srcPath = path4.join(skill.baseDir, file);
-          const destPath = path4.join(destDir, file);
-          const resolved = path4.resolve(destPath);
-          if (!resolved.startsWith(path4.resolve(destDir))) {
+          const srcPath = path5.join(skill.baseDir, file);
+          const destPath = path5.join(destDir, file);
+          const resolved2 = path5.resolve(destPath);
+          if (!resolved2.startsWith(path5.resolve(destDir))) {
             throw new FsError({
               message: `Path traversal detected in skill file: ${file}`,
               code: ERROR_CODES.FS_DELETE_FAILED,
@@ -454,7 +1072,7 @@ var SkillInstaller = class {
               context: { reason: "path_traversal", skillName: skill.name }
             });
           }
-          const stat3 = await fs4.stat(srcPath);
+          const stat3 = await fs5.stat(srcPath);
           if (stat3.size > MAX_SKILL_FILE_SIZE) {
             throw new FsError({
               message: `Skill file "${file}" is too large (${(stat3.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
@@ -463,8 +1081,8 @@ var SkillInstaller = class {
               context: { skillName: skill.name, fileSize: stat3.size, maxSize: MAX_SKILL_FILE_SIZE }
             });
           }
-          await fs4.mkdir(path4.dirname(destPath), { recursive: true });
-          await fs4.copyFile(srcPath, destPath);
+          await fs5.mkdir(path5.dirname(destPath), { recursive: true });
+          await fs5.copyFile(srcPath, destPath);
           copiedFiles.push(file);
         }
         const entry = {
@@ -474,7 +1092,12 @@ var SkillInstaller = class {
           scope,
           projectHash: scope === "project" ? this.opts.projectHash : void 0,
           installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          files: copiedFiles
+          files: copiedFiles,
+          // When the install came through a registry (e.g. skills.sh), record
+          // which adapter + registry id resolved to this GitHub repo, so the
+          // source is traceable. `source` stays `github:owner/repo` for
+          // backward compat with `/skill-update`.
+          ...resolved.fromRegistry ? { registryFrom: { adapterId: resolved.adapterId, registryId: resolved.registryId } } : {}
         };
         await this.manifest.addEntry(entry);
         results.push({
@@ -489,10 +1112,97 @@ var SkillInstaller = class {
       this.invalidateLoaderCache();
       return results;
     } finally {
-      await fs4.rm(tempDir, { recursive: true, force: true }).catch(() => {
+      await fs5.rm(tempDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
+  /**
+   * Import skills from a local directory (e.g. `.claude/skills`) into the
+   * project or user skills dir, optionally as symlinks. Used by `/skill-import`
+   * to take ownership of foreign skills so they can be edited/committed.
+   * Each direct subdirectory containing a valid `SKILL.md` is copied verbatim.
+   */
+  async importFromDir(srcDir, opts) {
+    const scope = opts?.global ? "user" : "project";
+    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
+    let entries;
+    try {
+      entries = await fs5.readdir(srcDir, { withFileTypes: true });
+    } catch {
+      throw new WrongStackError({
+        message: `Source directory not found or not readable: ${srcDir}`,
+        code: ERROR_CODES.VALIDATION_ERROR,
+        subsystem: "general",
+        context: { srcDir }
+      });
+    }
+    const results = [];
+    for (const e of entries) {
+      if (!await entryIsDirectory(srcDir, e)) continue;
+      const skillMdPath = path5.join(srcDir, e.name, "SKILL.md");
+      let content;
+      try {
+        content = await fs5.readFile(skillMdPath, "utf8");
+      } catch {
+        continue;
+      }
+      const fm = parseSkillFrontmatter(content);
+      if (!fm.name || !fm.description || !isValidSkillNameFormat(fm.name)) continue;
+      const existing = await this.manifest.findByName(fm.name);
+      if (existing.find((x) => x.scope === scope)) {
+        await this.removeSkillFiles(fm.name, scope);
+      }
+      const destDir = path5.join(targetDir, fm.name);
+      await fs5.mkdir(destDir, { recursive: true });
+      const srcSkillDir = path5.join(srcDir, e.name);
+      const files = await collectFiles(srcSkillDir, srcSkillDir);
+      const copiedFiles = [];
+      for (const file of files) {
+        const srcPath = path5.join(srcSkillDir, file);
+        const destPath = path5.join(destDir, file);
+        const resolved = path5.resolve(destPath);
+        if (!resolved.startsWith(path5.resolve(destDir))) {
+          throw new FsError({
+            message: `Path traversal detected in skill file: ${file}`,
+            code: ERROR_CODES.FS_DELETE_FAILED,
+            path: destPath,
+            context: { reason: "path_traversal", skillName: fm.name }
+          });
+        }
+        await fs5.mkdir(path5.dirname(destPath), { recursive: true });
+        if (opts?.link) {
+          try {
+            await fs5.symlink(srcPath, destPath);
+          } catch (err) {
+            await fs5.copyFile(srcPath, destPath);
+            this.opts.log?.(`symlink failed for ${file} (${toErrorMessage(err)}); copied instead`);
+          }
+        } else {
+          await fs5.copyFile(srcPath, destPath);
+        }
+        copiedFiles.push(file);
+      }
+      await this.manifest.addEntry({
+        name: fm.name,
+        source: `import:${srcDir}`,
+        ref: "-",
+        scope,
+        projectHash: scope === "project" ? this.opts.projectHash : void 0,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: copiedFiles
+      });
+      results.push({
+        name: fm.name,
+        path: destDir,
+        scope,
+        source: `import:${srcDir}`,
+        ref: "-",
+        skillCount: 1
+      });
+    }
+    this.invalidateLoaderCache();
+    return results;
+  }
   /**
    * Update installed skills.
    * - No args: update all
@@ -593,6 +1303,28 @@ var SkillInstaller = class {
   async listInstalled() {
     return this.manifest.listAll();
   }
+  /**
+   * Search across all configured registry adapters. Results from each adapter
+   * are merged (deduplicated by `installRef`, adapters earlier in the list win
+   * conflicts). Adapters that don't support search (e.g. github-direct)
+   * contribute nothing.
+   */
+  async search(query, opts) {
+    const settled = await Promise.allSettled(this.adapters.map((a) => a.search(query, opts)));
+    const perAdapter = [];
+    const errors = [];
+    settled.forEach((s, i) => {
+      if (s.status === "fulfilled") perAdapter.push(s.value);
+      else {
+        const id = this.adapters[i]?.id ?? "?";
+        errors.push(`${id}: ${toErrorMessage(s.reason)}`);
+      }
+    });
+    if (errors.length > 0) {
+      this.opts.log?.(`Some registries failed during search: ${errors.join("; ")}`);
+    }
+    return dedupeSearchResults(perAdapter);
+  }
   // ── Private helpers ──────────────────────────────────────────────
   /**
    * Detect skills in an extracted repository.
@@ -600,14 +1332,14 @@ var SkillInstaller = class {
    */
   async detectSkills(baseDir) {
     const results = [];
-    const rootSkillMd = path4.join(baseDir, "SKILL.md");
+    const rootSkillMd = path5.join(baseDir, "SKILL.md");
     try {
-      await fs4.access(rootSkillMd);
-      const content = await fs4.readFile(rootSkillMd, "utf8");
-      const meta = parseFrontmatter(content);
-      if (meta.name && meta.description) {
+      await fs5.access(rootSkillMd);
+      const content = await fs5.readFile(rootSkillMd, "utf8");
+      const fm = parseSkillFrontmatter(content);
+      if (fm.name && fm.description && isValidSkillNameFormat(fm.name)) {
         results.push({
-          name: meta.name,
+          name: fm.name,
           baseDir,
           files: ["SKILL.md"]
         });
@@ -615,20 +1347,20 @@ var SkillInstaller = class {
       }
     } catch {
     }
-    const skillsDir = path4.join(baseDir, "skills");
+    const skillsDir = path5.join(baseDir, "skills");
     try {
-      const entries = await fs4.readdir(skillsDir, { withFileTypes: true });
+      const entries = await fs5.readdir(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const skillFile = path4.join(skillsDir, entry.name, "SKILL.md");
+        const skillFile = path5.join(skillsDir, entry.name, "SKILL.md");
         try {
-          const content = await fs4.readFile(skillFile, "utf8");
-          const meta = parseFrontmatter(content);
-          if (meta.name && meta.description) {
-            const skillDir = path4.join(skillsDir, entry.name);
+          const content = await fs5.readFile(skillFile, "utf8");
+          const fm = parseSkillFrontmatter(content);
+          if (fm.name && fm.description && isValidSkillNameFormat(fm.name)) {
+            const skillDir = path5.join(skillsDir, entry.name);
             const files = await collectFiles(skillDir, skillDir);
             results.push({
-              name: meta.name,
+              name: fm.name,
               baseDir: skillDir,
               files
             });
@@ -645,8 +1377,8 @@ var SkillInstaller = class {
    */
   async removeSkillFiles(name, scope) {
     const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
-    const skillDir = path4.join(targetDir, name);
-    await fs4.rm(skillDir, { recursive: true, force: true });
+    const skillDir = path5.join(targetDir, name);
+    await fs5.rm(skillDir, { recursive: true, force: true });
   }
   /**
    * Invalidate the skill loader's cache so newly installed skills appear.
@@ -657,49 +1389,43 @@ var SkillInstaller = class {
       loader.invalidateCache();
     }
   }
-};
-function parseFrontmatter(raw) {
-  if (!raw.startsWith("---")) return {};
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return {};
-  const block = raw.slice(4, end);
-  const out = {};
-  let key = null;
-  let value = [];
-  const flush = () => {
-    if (key) {
-      out[key] = value.join("\n").trim();
-    }
-    key = null;
-    value = [];
-  };
-  for (const line of block.split("\n")) {
-    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
-    if (m) {
-      flush();
-      key = m[1] ?? "";
-      const pipe = m[2];
-      const rest = m[3] ?? "";
-      if (pipe === "|") {
-        value = [];
-      } else if (rest) {
-        value = [rest];
-      } else {
-        value = [];
+  /**
+   * Resolve an install ref, dispatching registry-prefixed refs to the matching
+   * adapter. Returns the concrete `user/repo[@ref]` install ref plus provenance
+   * (which adapter resolved it, if any).
+   */
+  resolveRef(refInput) {
+    const trimmed = refInput.trim();
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx > 0) {
+      const maybeAdapterId = trimmed.slice(0, colonIdx);
+      const adapter = this.adapters.find((a) => a.id === maybeAdapterId);
+      if (adapter) {
+        const registryId = trimmed.slice(colonIdx + 1);
+        const installRef = adapter.resolveInstallRef(registryId);
+        return { installRef, fromRegistry: true, adapterId: adapter.id, registryId };
       }
-    } else if (key) {
-      value.push(line.replace(/^\s+/, ""));
     }
+    return { installRef: trimmed, fromRegistry: false, adapterId: "", registryId: "" };
   }
-  flush();
-  return out;
+};
+async function entryIsDirectory(dir, entry) {
+  if (entry.isDirectory()) return true;
+  if (entry.isSymbolicLink()) {
+    try {
+      return (await fs5.stat(path5.join(dir, entry.name))).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  return false;
 }
 async function collectFiles(dir, baseDir) {
   const results = [];
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
-    const relPath = path4.relative(baseDir, fullPath);
+    const fullPath = path5.join(dir, entry.name);
+    const relPath = path5.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
       results.push(...await collectFiles(fullPath, baseDir));
@@ -709,7 +1435,24 @@ async function collectFiles(dir, baseDir) {
   }
   return results;
 }
+function dedupeSearchResults(perAdapter) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const block of perAdapter) {
+    const kept = [];
+    for (const r of block.results) {
+      const key = r.installRef;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      kept.push(r);
+    }
+    if (kept.length > 0 || block.results.length > 0) {
+      out.push({ ...block, results: kept });
+    }
+  }
+  return out;
+}
 
-export { SkillInstaller, SkillManifestStore, downloadGitHubTarball, parseSkillRef };
+export { DEFAULT_SKILLS_SH_URL, FOREIGN_SKILL_TOOLS, SKILL_LIMITS, SkillInstaller, SkillManifestStore, bodyLineAdvisory, createSkillsShAdapter, downloadGitHubTarball, extractSkillFromPrompt, generateSkillSkeleton, githubDirectAdapter, isValidSkillNameFormat, openInEditor, parseSkillFrontmatter, parseSkillRef, resolveForeignToolIds, resolveForeignToolIdsWithWarnings, securityScoreToTier, stripFrontmatter, validateSkillName, validateSkillNameAvailable, writeSkeletonSkill };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map