@serviceme/devtools-core 2.0.0 → 2.0.2

package/dist/skill-linker.js

@@ -1,441 +1,398 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/skill-linker/index.ts
-var skill_linker_exports = {};
-__export(skill_linker_exports, {
-  LinkError: () => LinkError,
-  convertToSymlink: () => convertToSymlink,
-  getPlatformHint: () => getPlatformHint,
-  installSkillToWorkspace: () => installSkillToWorkspace,
-  listLegacyUserScopeSkills: () => listLegacyUserScopeSkills,
-  listLinkedSkills: () => listLinkedSkills,
-  pickMode: () => pickMode,
-  resolveSkillLinkPath: () => resolveSkillLinkPath,
-  resolveSkillTarget: () => resolveSkillTarget,
-  resolveUserSkillLinkPath: () => resolveUserSkillLinkPath,
-  uninstallSkillFromWorkspace: () => uninstallSkillFromWorkspace
-});
-module.exports = __toCommonJS(skill_linker_exports);
-var fs = __toESM(require("fs/promises"));
-var path2 = __toESM(require("path"));
-
-// src/paths/userHome.ts
-var os = __toESM(require("os"));
-var path = __toESM(require("path"));
-var SERVICEME_DIR_NAME = ".serviceme";
-var REPOS_SUBDIR = "repos";
-var SAFE_REPO_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
-var SERVICEME_HOME_ENV = "SERVICEME_HOME";
-var activeOverrides = {};
-function resolveHomeDir() {
-  const injected = activeOverrides.homeDir;
-  if (injected !== void 0) {
-    return injected;
-  }
-  return os.homedir();
-}
-function resolveServicemeHomeEnv() {
-  const injected = activeOverrides.servicemeHomeEnv;
-  if (injected !== void 0) {
-    return injected.length > 0 ? injected : void 0;
-  }
-  const envValue = process.env[SERVICEME_HOME_ENV];
-  return envValue && envValue.length > 0 ? envValue : void 0;
-}
-function assertSafeRepoId(repoId) {
-  if (typeof repoId !== "string" || repoId.length === 0 || !SAFE_REPO_ID_PATTERN.test(repoId)) {
-    throw new Error(
-      `Invalid repo id: ${JSON.stringify(repoId)}. Must match ${SAFE_REPO_ID_PATTERN} (alphanumeric start, then alphanumerics / underscores / hyphens, \u2264 64 chars).`
-    );
-  }
-  return repoId;
-}
-function getHomeDir() {
-  return resolveHomeDir();
-}
-function getServicemeHome() {
-  const override = resolveServicemeHomeEnv();
-  if (override !== void 0) {
-    return path.resolve(override);
-  }
-  return path.join(resolveHomeDir(), SERVICEME_DIR_NAME);
-}
-function getReposDir() {
-  return path.join(getServicemeHome(), REPOS_SUBDIR);
-}
-function getRepoDir(repoId) {
-  return path.join(getReposDir(), assertSafeRepoId(repoId));
-}
-
-// src/skill-linker/index.ts
-var ENTRY_SUBDIR = {
-  skill: "skills",
-  agent: "agents"
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.js");
+const require_userHome = require("./userHome-BquDeFVE.js");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+//#region src/skill-linker/index.ts
+const ENTRY_SUBDIR = {
+	skill: "skills",
+	agent: "agents"
 };
+/**
+* Sentinel error for link failures. Carries the chosen mode + platform
+* hint so the UI can render an actionable message.
+*/
 var LinkError = class extends Error {
-  constructor(opts) {
-    super(
-      `failed to ${opts.mode} link ${opts.linkPath} \u2192 ${opts.target} on ${opts.platform}: ${opts.cause instanceof Error ? opts.cause.message : String(opts.cause)}`
-    );
-    this.name = "LinkError";
-    this.mode = opts.mode;
-    this.target = opts.target;
-    this.linkPath = opts.linkPath;
-    this.platform = opts.platform;
-    this.cause = opts.cause;
-  }
-  /** A user-facing hint for the platform that failed. */
-  hint() {
-    return getPlatformHint(this.platform);
-  }
+	constructor(opts) {
+		super(`failed to ${opts.mode} link ${opts.linkPath} → ${opts.target} on ${opts.platform}: ${opts.cause instanceof Error ? opts.cause.message : String(opts.cause)}`);
+		this.name = "LinkError";
+		this.mode = opts.mode;
+		this.target = opts.target;
+		this.linkPath = opts.linkPath;
+		this.platform = opts.platform;
+		this.cause = opts.cause;
+	}
+	/** A user-facing hint for the platform that failed. */
+	hint() {
+		return getPlatformHint(this.platform);
+	}
 };
+/** Choose the platform-optimal link mode. */
 function pickMode(platform = process.platform) {
-  return platform === "win32" ? "junction" : "symlink";
+	return platform === "win32" ? "junction" : "symlink";
 }
+/** A short hint string for the platform where the link failed. */
 function getPlatformHint(platform) {
-  if (platform === "win32") {
-    return "On Windows, enable Developer Mode in Settings \u2192 Privacy & Security \u2192 For developers, or run as Administrator. NTFS junction also requires the target to be on a local NTFS volume (OneDrive / network shares are not supported).";
-  }
-  return "Symlink creation failed. Check filesystem permissions and that the source directory exists. On some filesystems (FAT32, exFAT, network mounts) symlinks are not supported.";
+	if (platform === "win32") return "On Windows, enable Developer Mode in Settings → Privacy & Security → For developers, or run as Administrator. NTFS junction also requires the target to be on a local NTFS volume (OneDrive / network shares are not supported).";
+	return "Symlink creation failed. Check filesystem permissions and that the source directory exists. On some filesystems (FAT32, exFAT, network mounts) symlinks are not supported.";
 }
+/**
+* Resolve the source path inside `~/.serviceme/repos/<repoId>/{skills,agents}/<name>`.
+* Exported for callers that need to inspect the target without installing.
+*/
 function resolveSkillTarget(repoId, skillName, kind = "skill") {
-  return path2.join(getRepoDir(repoId), ENTRY_SUBDIR[kind], skillName);
+	return node_path.join(require_userHome.getRepoDir(repoId), ENTRY_SUBDIR[kind], skillName);
 }
+/**
+* Resolve the workspace link path — `<workspaceDir>/.github/{skills,agents}/<name>` —
+* the same directory Copilot/Claude actually scan.
+*/
 function resolveSkillLinkPath(workspaceDir, skillName, kind = "skill") {
-  return path2.join(workspaceDir, ".github", ENTRY_SUBDIR[kind], skillName);
+	return node_path.join(workspaceDir, ".github", ENTRY_SUBDIR[kind], skillName);
 }
+/**
+* Resolve the user-scope link path — `~/.copilot/{skills,agents}/<name>` —
+* visible to every workspace.
+*/
 function resolveUserSkillLinkPath(skillName, kind = "skill") {
-  return path2.join(getHomeDir(), ".copilot", ENTRY_SUBDIR[kind], skillName);
+	return node_path.join(require_userHome.getHomeDir(), ".copilot", ENTRY_SUBDIR[kind], skillName);
 }
 function resolveLinkPath(opts) {
-  if (opts.scope === "workspace" && !opts.workspaceDir) {
-    throw new Error(
-      "workspaceDir is required for scope: 'workspace' (pass scope: 'user' for a global install instead)."
-    );
-  }
-  const base = opts.scope === "user" ? resolveUserSkillLinkPath(opts.skillName, opts.kind) : resolveSkillLinkPath(opts.workspaceDir, opts.skillName, opts.kind);
-  return opts.linkBasename ? path2.join(path2.dirname(base), opts.linkBasename) : base;
+	if (opts.scope === "workspace" && !opts.workspaceDir) throw new Error("workspaceDir is required for scope: 'workspace' (pass scope: 'user' for a global install instead).");
+	const base = opts.scope === "user" ? resolveUserSkillLinkPath(opts.skillName, opts.kind) : resolveSkillLinkPath(opts.workspaceDir, opts.skillName, opts.kind);
+	return opts.linkBasename ? node_path.join(node_path.dirname(base), opts.linkBasename) : base;
 }
+/**
+* Install a skill into a workspace by creating a link at the standard
+* path. Throws `LinkError` on failure (no silent copy fallback per
+* §11.8).
+*
+* Idempotent: if the correct link already exists, returns the existing
+* record without touching the filesystem. If a *wrong* link exists at
+* the target path, it is replaced.
+*/
 async function installSkillToWorkspace(opts) {
-  const kind = opts.kind ?? "skill";
-  const scope = opts.scope ?? "workspace";
-  const isFile = opts.sourceIsFile ?? false;
-  const target = opts.sourcePath ?? resolveSkillTarget(opts.repoId, opts.skillName, kind);
-  const linkPath = resolveLinkPath({
-    workspaceDir: opts.workspaceDir,
-    skillName: opts.skillName,
-    kind,
-    scope,
-    linkBasename: isFile ? path2.basename(target) : void 0
-  });
-  await fs.access(target).catch(() => {
-    throw new LinkError({
-      mode: "symlink",
-      // placeholder — mode not chosen yet
-      target,
-      linkPath,
-      platform: process.platform,
-      cause: new Error(`skill source not found: ${target}`)
-    });
-  });
-  if (await isCorrectLink(linkPath, target)) {
-    return { mode: "symlink", linkPath, targetPath: target };
-  }
-  await removeIfExists(linkPath);
-  const requestedMode = opts.mode === void 0 || opts.mode === "auto" ? pickMode() : opts.mode;
-  const mode = isFile && requestedMode === "junction" ? "symlink" : requestedMode;
-  await fs.mkdir(path2.dirname(linkPath), { recursive: true });
-  try {
-    if (mode === "junction") {
-      await fs.symlink(target, linkPath, "junction");
-    } else if (mode === "symlink") {
-      await fs.symlink(target, linkPath, isFile ? "file" : "dir");
-    } else {
-      throw new LinkError({
-        mode: "copy",
-        target,
-        linkPath,
-        platform: process.platform,
-        cause: new Error(
-          "copy mode is not supported in v1 \u2014 see spec \xA711.8 (throw, not copy fallback)"
-        )
-      });
-    }
-  } catch (err) {
-    if (err instanceof LinkError) throw err;
-    throw new LinkError({
-      mode,
-      target,
-      linkPath,
-      platform: process.platform,
-      cause: err
-    });
-  }
-  return { mode, linkPath, targetPath: target };
+	const kind = opts.kind ?? "skill";
+	const scope = opts.scope ?? "workspace";
+	const isFile = opts.sourceIsFile ?? false;
+	const target = opts.sourcePath ?? resolveSkillTarget(opts.repoId, opts.skillName, kind);
+	const linkPath = resolveLinkPath({
+		workspaceDir: opts.workspaceDir,
+		skillName: opts.skillName,
+		kind,
+		scope,
+		linkBasename: isFile ? node_path.basename(target) : void 0
+	});
+	await node_fs_promises.access(target).catch(() => {
+		throw new LinkError({
+			mode: "symlink",
+			target,
+			linkPath,
+			platform: process.platform,
+			cause: /* @__PURE__ */ new Error(`skill source not found: ${target}`)
+		});
+	});
+	if (await isCorrectLink(linkPath, target)) return {
+		mode: "symlink",
+		linkPath,
+		targetPath: target
+	};
+	await removeIfExists(linkPath);
+	const requestedMode = opts.mode === void 0 || opts.mode === "auto" ? pickMode() : opts.mode;
+	const mode = isFile && requestedMode === "junction" ? "symlink" : requestedMode;
+	await node_fs_promises.mkdir(node_path.dirname(linkPath), { recursive: true });
+	try {
+		if (mode === "junction") await node_fs_promises.symlink(target, linkPath, "junction");
+		else if (mode === "symlink") await node_fs_promises.symlink(target, linkPath, isFile ? "file" : "dir");
+		else throw new LinkError({
+			mode: "copy",
+			target,
+			linkPath,
+			platform: process.platform,
+			cause: /* @__PURE__ */ new Error("copy mode is not supported in v1 — see spec §11.8 (throw, not copy fallback)")
+		});
+	} catch (err) {
+		if (err instanceof LinkError) throw err;
+		throw new LinkError({
+			mode,
+			target,
+			linkPath,
+			platform: process.platform,
+			cause: err
+		});
+	}
+	return {
+		mode,
+		linkPath,
+		targetPath: target
+	};
 }
+/**
+* Convert an existing, real (non-symlink) skill/agent directory at the
+* standard scan path into a symlink pointing at the matching global
+* repo entry. Refuses to run when there's nothing real to convert —
+* callers should only surface this action when a marketplace/scope
+* state check already confirmed a non-symlink install is present.
+*/
 async function convertToSymlink(opts) {
-  const kind = opts.kind ?? "skill";
-  const scope = opts.scope ?? "workspace";
-  const linkPath = resolveLinkPath({
-    workspaceDir: opts.workspaceDir,
-    skillName: opts.skillName,
-    kind,
-    scope,
-    linkBasename: opts.sourceIsFile && opts.sourcePath ? path2.basename(opts.sourcePath) : void 0
-  });
-  const stat2 = await fs.lstat(linkPath).catch(() => null);
-  if (!stat2) {
-    throw new Error(`Nothing installed at ${linkPath} to convert.`);
-  }
-  if (stat2.isSymbolicLink()) {
-    throw new Error(`${linkPath} is already a symlink.`);
-  }
-  return installSkillToWorkspace(opts);
+	const kind = opts.kind ?? "skill";
+	const scope = opts.scope ?? "workspace";
+	const linkPath = resolveLinkPath({
+		workspaceDir: opts.workspaceDir,
+		skillName: opts.skillName,
+		kind,
+		scope,
+		linkBasename: opts.sourceIsFile && opts.sourcePath ? node_path.basename(opts.sourcePath) : void 0
+	});
+	const stat = await node_fs_promises.lstat(linkPath).catch(() => null);
+	if (!stat) throw new Error(`Nothing installed at ${linkPath} to convert.`);
+	if (stat.isSymbolicLink()) throw new Error(`${linkPath} is already a symlink.`);
+	return installSkillToWorkspace(opts);
 }
+/**
+* Remove a skill/agent link from a workspace/user scope. Idempotent:
+* succeeds when the link does not exist (no error).
+*
+* Tries the bare `<name>` path first (directory-based entries), then
+* falls back to scanning the scope dir for a `<name>.<ext>` file (flat
+* manifest entries, e.g. `CSharpExpert.agent.md`) — the caller doesn't
+* necessarily still have the source repo entry to know which shape was
+* installed (e.g. the repo may have been removed since).
+*/
 async function uninstallSkillFromWorkspace(opts) {
-  const kind = opts.kind ?? "skill";
-  const scope = opts.scope ?? "workspace";
-  const linkPath = resolveLinkPath({
-    workspaceDir: opts.workspaceDir,
-    skillName: opts.skillName,
-    kind,
-    scope
-  });
-  if (await pathExists(linkPath)) {
-    await removeIfExists(linkPath);
-    return;
-  }
-  const scopeDir = path2.dirname(linkPath);
-  let entries;
-  try {
-    entries = await fs.readdir(scopeDir, { withFileTypes: true });
-  } catch {
-    entries = [];
-  }
-  const flatMatch = entries.find(
-    (e) => e.name === opts.skillName || e.name.startsWith(`${opts.skillName}.`)
-  );
-  if (flatMatch) {
-    await removeIfExists(path2.join(scopeDir, flatMatch.name));
-    return;
-  }
-  if (scope === "user") {
-    const legacyDir = path2.join(getHomeDir(), LEGACY_USER_SCOPE_ROOT, ENTRY_SUBDIR[kind]);
-    const legacyEntries = await fs.readdir(legacyDir, { withFileTypes: true }).catch(() => []);
-    const legacyMatch = legacyEntries.find(
-      (e) => e.name === opts.skillName || e.name.startsWith(`${opts.skillName}.`)
-    );
-    if (legacyMatch) {
-      await removeIfExists(path2.join(legacyDir, legacyMatch.name));
-    }
-  }
+	const kind = opts.kind ?? "skill";
+	const scope = opts.scope ?? "workspace";
+	const linkPath = resolveLinkPath({
+		workspaceDir: opts.workspaceDir,
+		skillName: opts.skillName,
+		kind,
+		scope
+	});
+	if (await pathExists(linkPath)) {
+		await removeIfExists(linkPath);
+		return;
+	}
+	const scopeDir = node_path.dirname(linkPath);
+	let entries;
+	try {
+		entries = await node_fs_promises.readdir(scopeDir, { withFileTypes: true });
+	} catch {
+		entries = [];
+	}
+	const flatMatch = entries.find((e) => e.name === opts.skillName || e.name.startsWith(`${opts.skillName}.`));
+	if (flatMatch) {
+		await removeIfExists(node_path.join(scopeDir, flatMatch.name));
+		return;
+	}
+	if (scope === "user") {
+		const legacyDir = node_path.join(require_userHome.getHomeDir(), LEGACY_USER_SCOPE_ROOT, ENTRY_SUBDIR[kind]);
+		const legacyMatch = (await node_fs_promises.readdir(legacyDir, { withFileTypes: true }).catch(() => [])).find((e) => e.name === opts.skillName || e.name.startsWith(`${opts.skillName}.`));
+		if (legacyMatch) await removeIfExists(node_path.join(legacyDir, legacyMatch.name));
+	}
 }
+/** `true` when `p` exists (following symlinks is irrelevant — `lstat` is enough). */
 async function pathExists(p) {
-  try {
-    await fs.lstat(p);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		await node_fs_promises.lstat(p);
+		return true;
+	} catch {
+		return false;
+	}
 }
-var MANIFEST_FILENAME = {
-  skill: "SKILL.md",
-  agent: "AGENT.md"
+const MANIFEST_FILENAME = {
+	skill: "SKILL.md",
+	agent: "AGENT.md"
 };
-var LEGACY_USER_SCOPE_ROOT = ".agents";
+/**
+* Legacy user-scope root used before the migration to `~/.copilot`.
+* Kept readable so user-scope listing can surface old links instead of
+* silently hiding content the user still has installed.
+*/
+const LEGACY_USER_SCOPE_ROOT = ".agents";
+/**
+* Enumerate all skill/agent entries currently present in a workspace/user
+* scope — both symlinked installs (`mode: "symlink"`/`"junction"`) AND
+* real, non-symlink directories/files that already carry a valid
+* manifest (`mode: "copy"`). Used by the UI's "Manage installed skills"
+* view so it can show a real (copy-installed) entry as installed too —
+* this is common for the user (global) scope, where many skills are
+* placed by other tools/installers as plain copies rather than via this
+* package's symlink-only install flow. `repoId` is `""` for `"copy"`
+* entries since there's no symlink target to resolve it from; callers
+* match these by name only. Returns an empty array when the scan
+* directory doesn't exist.
+*/
 async function listLinkedSkills(workspaceDir, kind = "skill", scope = "workspace") {
-  if (scope === "workspace" && !workspaceDir) {
-    return [];
-  }
-  const userRoot = path2.join(getHomeDir(), ".copilot", ENTRY_SUBDIR[kind]);
-  const root = scope === "user" ? userRoot : path2.join(workspaceDir, ".github", ENTRY_SUBDIR[kind]);
-  let entries;
-  try {
-    entries = await fs.readdir(root, { withFileTypes: true });
-  } catch (err) {
-    if (err.code === "ENOENT") return [];
-    throw err;
-  }
-  const results = [];
-  for (const entry of entries) {
-    const entryPath = path2.join(root, entry.name);
-    if (entry.isSymbolicLink()) {
-      const skillName = entry.name.replace(/\.(agent|skill)\.md$/, "");
-      const rawTarget = await readLinkTarget(entryPath);
-      if (!rawTarget) continue;
-      const resolvedTarget = resolveTargetPath(entryPath, rawTarget);
-      const targetStat = await fs.stat(resolvedTarget).catch(() => null);
-      if (!targetStat) continue;
-      results.push({
-        repoId: extractRepoIdFromTarget(resolvedTarget) ?? "",
-        skillName,
-        linkPath: entryPath,
-        targetPath: resolvedTarget,
-        mode: process.platform === "win32" ? "junction" : "symlink",
-        scope
-      });
-      continue;
-    }
-    if (entry.isDirectory()) {
-      const hasManifest = await fs.access(path2.join(entryPath, MANIFEST_FILENAME[kind])).then(() => true).catch(() => false);
-      if (!hasManifest) continue;
-      results.push({
-        repoId: "",
-        skillName: entry.name,
-        linkPath: entryPath,
-        targetPath: entryPath,
-        mode: "copy",
-        scope
-      });
-      continue;
-    }
-    if (entry.isFile() && entry.name.endsWith(`.${kind}.md`)) {
-      results.push({
-        repoId: "",
-        skillName: entry.name.replace(/\.(agent|skill)\.md$/, ""),
-        linkPath: entryPath,
-        targetPath: entryPath,
-        mode: "copy",
-        scope
-      });
-    }
-  }
-  if (scope === "user") {
-    const seen = new Set(results.map((r) => r.skillName));
-    for (const legacy of await listLegacyUserScopeSkills(kind)) {
-      if (!seen.has(legacy.skillName)) {
-        results.push(legacy);
-      }
-    }
-  }
-  return results;
+	if (scope === "workspace" && !workspaceDir) return [];
+	const userRoot = node_path.join(require_userHome.getHomeDir(), ".copilot", ENTRY_SUBDIR[kind]);
+	const root = scope === "user" ? userRoot : node_path.join(workspaceDir, ".github", ENTRY_SUBDIR[kind]);
+	let entries;
+	try {
+		entries = await node_fs_promises.readdir(root, { withFileTypes: true });
+	} catch (err) {
+		if (err.code === "ENOENT") return [];
+		throw err;
+	}
+	const results = [];
+	for (const entry of entries) {
+		const entryPath = node_path.join(root, entry.name);
+		if (entry.isSymbolicLink()) {
+			const skillName = entry.name.replace(/\.(agent|skill)\.md$/, "");
+			const rawTarget = await readLinkTarget(entryPath);
+			if (!rawTarget) continue;
+			const resolvedTarget = resolveTargetPath(entryPath, rawTarget);
+			if (!await node_fs_promises.stat(resolvedTarget).catch(() => null)) continue;
+			results.push({
+				repoId: extractRepoIdFromTarget(resolvedTarget) ?? "",
+				skillName,
+				linkPath: entryPath,
+				targetPath: resolvedTarget,
+				mode: process.platform === "win32" ? "junction" : "symlink",
+				scope
+			});
+			continue;
+		}
+		if (entry.isDirectory()) {
+			if (!await node_fs_promises.access(node_path.join(entryPath, MANIFEST_FILENAME[kind])).then(() => true).catch(() => false)) continue;
+			results.push({
+				repoId: "",
+				skillName: entry.name,
+				linkPath: entryPath,
+				targetPath: entryPath,
+				mode: "copy",
+				scope
+			});
+			continue;
+		}
+		if (entry.isFile() && entry.name.endsWith(`.${kind}.md`)) results.push({
+			repoId: "",
+			skillName: entry.name.replace(/\.(agent|skill)\.md$/, ""),
+			linkPath: entryPath,
+			targetPath: entryPath,
+			mode: "copy",
+			scope
+		});
+	}
+	if (scope === "user") {
+		const seen = new Set(results.map((r) => r.skillName));
+		for (const legacy of await listLegacyUserScopeSkills(kind)) if (!seen.has(legacy.skillName)) results.push(legacy);
+	}
+	return results;
 }
+/**
+* List entries still living in the legacy `~/.agents` user scope.
+* Read-only: migration is an explicit user action elsewhere.
+*/
 async function listLegacyUserScopeSkills(kind = "skill") {
-  const root = path2.join(getHomeDir(), LEGACY_USER_SCOPE_ROOT, ENTRY_SUBDIR[kind]);
-  let entries;
-  try {
-    entries = await fs.readdir(root, { withFileTypes: true });
-  } catch (err) {
-    if (err.code === "ENOENT") return [];
-    throw err;
-  }
-  const results = [];
-  for (const entry of entries) {
-    const entryPath = path2.join(root, entry.name);
-    if (entry.isSymbolicLink()) {
-      const skillName = entry.name.replace(/\.(agent|skill)\.md$/, "");
-      const rawTarget = await readLinkTarget(entryPath);
-      if (!rawTarget) continue;
-      const resolvedTarget = resolveTargetPath(entryPath, rawTarget);
-      const targetStat = await fs.stat(resolvedTarget).catch(() => null);
-      if (!targetStat) continue;
-      results.push({
-        repoId: extractRepoIdFromTarget(resolvedTarget) ?? "",
-        skillName,
-        linkPath: entryPath,
-        targetPath: resolvedTarget,
-        mode: process.platform === "win32" ? "junction" : "symlink",
-        scope: "user"
-      });
-    } else if (entry.isDirectory()) {
-      const manifestPath = path2.join(entryPath, MANIFEST_FILENAME[kind]);
-      const stat2 = await fs.stat(manifestPath).catch(() => null);
-      if (stat2?.isFile()) {
-        results.push({
-          repoId: "",
-          skillName: entry.name,
-          linkPath: entryPath,
-          targetPath: manifestPath,
-          mode: "copy",
-          scope: "user"
-        });
-      }
-    }
-  }
-  return results;
+	const root = node_path.join(require_userHome.getHomeDir(), LEGACY_USER_SCOPE_ROOT, ENTRY_SUBDIR[kind]);
+	let entries;
+	try {
+		entries = await node_fs_promises.readdir(root, { withFileTypes: true });
+	} catch (err) {
+		if (err.code === "ENOENT") return [];
+		throw err;
+	}
+	const results = [];
+	for (const entry of entries) {
+		const entryPath = node_path.join(root, entry.name);
+		if (entry.isSymbolicLink()) {
+			const skillName = entry.name.replace(/\.(agent|skill)\.md$/, "");
+			const rawTarget = await readLinkTarget(entryPath);
+			if (!rawTarget) continue;
+			const resolvedTarget = resolveTargetPath(entryPath, rawTarget);
+			if (!await node_fs_promises.stat(resolvedTarget).catch(() => null)) continue;
+			results.push({
+				repoId: extractRepoIdFromTarget(resolvedTarget) ?? "",
+				skillName,
+				linkPath: entryPath,
+				targetPath: resolvedTarget,
+				mode: process.platform === "win32" ? "junction" : "symlink",
+				scope: "user"
+			});
+		} else if (entry.isDirectory()) {
+			const manifestPath = node_path.join(entryPath, MANIFEST_FILENAME[kind]);
+			if ((await node_fs_promises.stat(manifestPath).catch(() => null))?.isFile()) results.push({
+				repoId: "",
+				skillName: entry.name,
+				linkPath: entryPath,
+				targetPath: manifestPath,
+				mode: "copy",
+				scope: "user"
+			});
+		}
+	}
+	return results;
 }
+/** Returns `true` when `linkPath` is a symlink/junction pointing at `expectedTarget`. */
 async function isCorrectLink(linkPath, expectedTarget) {
-  let actual;
-  try {
-    actual = await readLinkTarget(linkPath);
-  } catch {
-    return false;
-  }
-  if (!actual) return false;
-  return resolveTargetPath(linkPath, actual) === resolveTargetPath(linkPath, expectedTarget);
+	let actual;
+	try {
+		actual = await readLinkTarget(linkPath);
+	} catch {
+		return false;
+	}
+	if (!actual) return false;
+	return resolveTargetPath(linkPath, actual) === resolveTargetPath(linkPath, expectedTarget);
 }
+/** Read a link's target without throwing — returns undefined on ENOENT. */
 async function readLinkTarget(linkPath) {
-  try {
-    return await fs.readlink(linkPath);
-  } catch (err) {
-    if (err.code === "ENOENT") return void 0;
-    throw err;
-  }
+	try {
+		return await node_fs_promises.readlink(linkPath);
+	} catch (err) {
+		if (err.code === "ENOENT") return void 0;
+		throw err;
+	}
 }
+/**
+* Resolve a relative symlink target against its parent directory so a
+* relative link reads back as an absolute path comparable to another
+* absolute path.
+*/
 function resolveTargetPath(linkPath, target) {
-  if (path2.isAbsolute(target)) return path2.normalize(target);
-  return path2.normalize(path2.resolve(path2.dirname(linkPath), target));
+	if (node_path.isAbsolute(target)) return node_path.normalize(target);
+	return node_path.normalize(node_path.resolve(node_path.dirname(linkPath), target));
 }
+/**
+* Parse the `<repoId>` segment back out of a resolved link target of
+* the shape `.../.serviceme/repos/<repoId>/{skills,agents}/<name>`.
+* Returns `undefined` when the target doesn't match that shape (e.g. a
+* hand-authored local skill under `~/.agents/skills/<name>` with no
+* backing repo).
+*/
 function extractRepoIdFromTarget(target) {
-  const marker = `${path2.sep}repos${path2.sep}`;
-  const idx = target.indexOf(marker);
-  if (idx === -1) return void 0;
-  const rest = target.slice(idx + marker.length);
-  const [repoId] = rest.split(path2.sep);
-  return repoId || void 0;
+	const marker = `${node_path.sep}repos${node_path.sep}`;
+	const idx = target.indexOf(marker);
+	if (idx === -1) return void 0;
+	const [repoId] = target.slice(idx + marker.length).split(node_path.sep);
+	return repoId || void 0;
 }
+/** Best-effort removal of a path. ENOENT is silently ignored. */
 async function removeIfExists(p) {
-  try {
-    const stat2 = await fs.lstat(p);
-    if (stat2.isDirectory() && !stat2.isSymbolicLink()) {
-      await fs.rm(p, { recursive: true, force: true });
-    } else {
-      await fs.unlink(p);
-    }
-  } catch (err) {
-    if (err.code === "ENOENT") return;
-    throw err;
-  }
+	try {
+		const stat = await node_fs_promises.lstat(p);
+		if (stat.isDirectory() && !stat.isSymbolicLink()) await node_fs_promises.rm(p, {
+			recursive: true,
+			force: true
+		});
+		else await node_fs_promises.unlink(p);
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		throw err;
+	}
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LinkError,
-  convertToSymlink,
-  getPlatformHint,
-  installSkillToWorkspace,
-  listLegacyUserScopeSkills,
-  listLinkedSkills,
-  pickMode,
-  resolveSkillLinkPath,
-  resolveSkillTarget,
-  resolveUserSkillLinkPath,
-  uninstallSkillFromWorkspace
-});
+//#endregion
+exports.LinkError = LinkError;
+exports.convertToSymlink = convertToSymlink;
+exports.getPlatformHint = getPlatformHint;
+exports.installSkillToWorkspace = installSkillToWorkspace;
+exports.listLegacyUserScopeSkills = listLegacyUserScopeSkills;
+exports.listLinkedSkills = listLinkedSkills;
+exports.pickMode = pickMode;
+exports.resolveSkillLinkPath = resolveSkillLinkPath;
+exports.resolveSkillTarget = resolveSkillTarget;
+exports.resolveUserSkillLinkPath = resolveUserSkillLinkPath;
+exports.uninstallSkillFromWorkspace = uninstallSkillFromWorkspace;
+
 //# sourceMappingURL=skill-linker.js.map