allagents 0.17.2 → 0.19.1

package/dist/index.js

@@ -11382,7 +11382,7 @@ var init_zod = __esm(() => {
 });
 
 // src/models/workspace-config.ts
-var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, VscodeConfigSchema, WorkspaceConfigSchema;
+var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, VscodeConfigSchema, SyncModeSchema, WorkspaceConfigSchema;
 var init_workspace_config = __esm(() => {
   init_zod();
   RepositorySchema = exports_external.object({
@@ -11417,12 +11417,14 @@ var init_workspace_config = __esm(() => {
   VscodeConfigSchema = exports_external.object({
     output: exports_external.string().optional()
   });
+  SyncModeSchema = exports_external.enum(["symlink", "copy"]);
   WorkspaceConfigSchema = exports_external.object({
     workspace: WorkspaceSchema.optional(),
     repositories: exports_external.array(RepositorySchema),
     plugins: exports_external.array(PluginSourceSchema),
     clients: exports_external.array(ClientTypeSchema),
-    vscode: VscodeConfigSchema.optional()
+    vscode: VscodeConfigSchema.optional(),
+    syncMode: SyncModeSchema.optional()
   });
 });
 
@@ -21223,7 +21225,10 @@ var init_glob_patterns = __esm(() => {
 });
 
 // src/models/client-mapping.ts
-var CLIENT_MAPPINGS, USER_CLIENT_MAPPINGS;
+function isUniversalClient(client) {
+  return CLIENT_MAPPINGS[client].skillsPath === CANONICAL_SKILLS_PATH;
+}
+var CLIENT_MAPPINGS, CANONICAL_SKILLS_PATH = ".agents/skills/", USER_CLIENT_MAPPINGS;
 var init_client_mapping = __esm(() => {
   CLIENT_MAPPINGS = {
     claude: {
@@ -24858,10 +24863,72 @@ var init_skill = __esm(() => {
   import_gray_matter = __toESM(require_gray_matter(), 1);
 });
 
+// src/utils/symlink.ts
+import { symlink, lstat, readlink, rm as rm2, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2, relative, resolve as resolve4 } from "node:path";
+import { platform } from "node:os";
+import { realpath } from "node:fs/promises";
+async function resolveParentSymlinks(path) {
+  const resolved = resolve4(path);
+  const dir = dirname2(resolved);
+  const base = resolved.substring(dir.length + 1);
+  try {
+    const realDir = await realpath(dir);
+    return `${realDir}/${base}`;
+  } catch {
+    return resolved;
+  }
+}
+function resolveSymlinkTarget(linkPath, linkTarget) {
+  return resolve4(dirname2(linkPath), linkTarget);
+}
+async function createSymlink(target, linkPath) {
+  try {
+    const resolvedTarget = resolve4(target);
+    const resolvedLinkPath = resolve4(linkPath);
+    if (resolvedTarget === resolvedLinkPath) {
+      return true;
+    }
+    const realTarget = await resolveParentSymlinks(target);
+    const realLinkPath = await resolveParentSymlinks(linkPath);
+    if (realTarget === realLinkPath) {
+      return true;
+    }
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = await readlink(linkPath);
+        if (resolveSymlinkTarget(linkPath, existingTarget) === resolvedTarget) {
+          return true;
+        }
+        await rm2(linkPath);
+      } else {
+        await rm2(linkPath, { recursive: true });
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") {
+        try {
+          await rm2(linkPath, { force: true });
+        } catch {}
+      }
+    }
+    const linkDir = dirname2(linkPath);
+    await mkdir2(linkDir, { recursive: true });
+    const realLinkDir = await resolveParentSymlinks(linkDir);
+    const relativePath = relative(realLinkDir, target);
+    const symlinkType = platform() === "win32" ? "junction" : undefined;
+    await symlink(relativePath, linkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_symlink = () => {};
+
 // src/core/transform.ts
-import { readFile as readFile4, writeFile, mkdir as mkdir2, cp, readdir as readdir2 } from "node:fs/promises";
+import { readFile as readFile4, writeFile, mkdir as mkdir3, cp, readdir as readdir2 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join6, dirname as dirname2 } from "node:path";
+import { join as join6, dirname as dirname3 } from "node:path";
 async function ensureWorkspaceRules(filePath, rules) {
   const rulesContent = rules ?? WORKSPACE_RULES;
   const startMarker = "<!-- WORKSPACE-RULES:START -->";
@@ -24898,7 +24965,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   }
   const destDir = join6(workspacePath, mapping.commandsPath);
   if (!dryRun) {
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
   }
   const files = await readdir2(sourceDir);
   const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -24924,7 +24991,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   return Promise.all(copyPromises);
 }
 async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false, skillNameMap } = options2;
+  const { dryRun = false, skillNameMap, syncMode = "copy", canonicalSkillsPath } = options2;
   const mapping = getMapping(client, options2);
   const results = [];
   if (!mapping.skillsPath) {
@@ -24936,10 +25003,11 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
   }
   const destDir = join6(workspacePath, mapping.skillsPath);
   if (!dryRun) {
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
   }
   const entries = await readdir2(sourceDir, { withFileTypes: true });
   const skillDirs = entries.filter((e) => e.isDirectory());
+  const useSymlinks = syncMode === "symlink" && !isUniversalClient(client) && canonicalSkillsPath;
   const copyPromises = skillDirs.map(async (entry) => {
     const skillSourcePath = join6(sourceDir, entry.name);
     const resolvedName = skillNameMap?.get(entry.name) ?? entry.name;
@@ -24960,6 +25028,17 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
         action: "copied"
       };
     }
+    if (useSymlinks) {
+      const canonicalSkillPath = join6(workspacePath, canonicalSkillsPath, resolvedName);
+      const symlinkCreated = await createSymlink(canonicalSkillPath, skillDestPath);
+      if (symlinkCreated) {
+        return {
+          source: canonicalSkillPath,
+          destination: skillDestPath,
+          action: "copied"
+        };
+      }
+    }
     try {
       await cp(skillSourcePath, skillDestPath, { recursive: true });
       return {
@@ -25008,7 +25087,7 @@ async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
     results.push({ source: sourceDir, destination: destDir, action: "copied" });
     return results;
   }
-  await mkdir2(destDir, { recursive: true });
+  await mkdir3(destDir, { recursive: true });
   try {
     await cp(sourceDir, destDir, { recursive: true });
     results.push({ source: sourceDir, destination: destDir, action: "copied" });
@@ -25035,7 +25114,7 @@ async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
   }
   const destDir = join6(workspacePath, mapping.agentsPath);
   if (!dryRun) {
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
   }
   const files = await readdir2(sourceDir);
   const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -25061,10 +25140,15 @@ async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
   return Promise.all(copyPromises);
 }
 async function copyPluginToWorkspace(pluginPath, workspacePath, client, options2 = {}) {
-  const { skillNameMap, ...baseOptions } = options2;
+  const { skillNameMap, syncMode, canonicalSkillsPath, ...baseOptions } = options2;
   const [commandResults, skillResults, hookResults, agentResults] = await Promise.all([
     copyCommands(pluginPath, workspacePath, client, baseOptions),
-    copySkills(pluginPath, workspacePath, client, { ...baseOptions, ...skillNameMap && { skillNameMap } }),
+    copySkills(pluginPath, workspacePath, client, {
+      ...baseOptions,
+      ...skillNameMap && { skillNameMap },
+      ...syncMode && { syncMode },
+      ...canonicalSkillsPath && { canonicalSkillsPath }
+    }),
     copyHooks(pluginPath, workspacePath, client, baseOptions),
     copyAgents(pluginPath, workspacePath, client, baseOptions)
   ]);
@@ -25181,7 +25265,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
           continue;
         }
         try {
-          await mkdir2(dirname2(destPath), { recursive: true });
+          await mkdir3(dirname3(destPath), { recursive: true });
           const content = await readFile4(resolved.sourcePath, "utf-8");
           await writeFile(destPath, content, "utf-8");
           results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
@@ -25252,7 +25336,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
       continue;
     }
     try {
-      await mkdir2(dirname2(destPath), { recursive: true });
+      await mkdir3(dirname3(destPath), { recursive: true });
       const content = await readFile4(srcPath, "utf-8");
       await writeFile(destPath, content, "utf-8");
       results.push({ source: srcPath, destination: destPath, action: "copied" });
@@ -25292,6 +25376,7 @@ var init_transform = __esm(() => {
   init_skill();
   init_constants();
   init_plugin_path();
+  init_symlink();
   AGENT_FILES2 = ["AGENTS.md", "CLAUDE.md"];
   injectWorkspaceRules = ensureWorkspaceRules;
 });
@@ -25351,7 +25436,7 @@ var init_marketplace_manifest = __esm(() => {
 // src/utils/marketplace-manifest-parser.ts
 import { readFile as readFile5 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join7, resolve as resolve4 } from "node:path";
+import { join as join7, resolve as resolve5 } from "node:path";
 async function parseMarketplaceManifest(marketplacePath) {
   const manifestPath = join7(marketplacePath, MANIFEST_PATH);
   if (!existsSync5(manifestPath)) {
@@ -25455,7 +25540,7 @@ function resolvePluginSourcePath(source, marketplacePath) {
   if (typeof source === "object") {
     return source.url;
   }
-  return resolve4(marketplacePath, source);
+  return resolve5(marketplacePath, source);
 }
 var MANIFEST_PATH = ".claude-plugin/marketplace.json";
 var init_marketplace_manifest_parser = __esm(() => {
@@ -25473,19 +25558,21 @@ __export(exports_user_workspace, {
   getUserWorkspaceConfigPath: () => getUserWorkspaceConfigPath,
   getUserWorkspaceConfig: () => getUserWorkspaceConfig,
   getUserPluginsForMarketplace: () => getUserPluginsForMarketplace,
+  getInstalledUserPlugins: () => getInstalledUserPlugins,
+  getInstalledProjectPlugins: () => getInstalledProjectPlugins,
   ensureUserWorkspace: () => ensureUserWorkspace,
   addUserPlugin: () => addUserPlugin
 });
-import { readFile as readFile6, writeFile as writeFile2, mkdir as mkdir3 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile2, mkdir as mkdir4 } from "node:fs/promises";
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join8, resolve as resolve5 } from "node:path";
+import { join as join8, resolve as resolve6 } from "node:path";
 function getUserWorkspaceConfigPath() {
   return join8(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
 }
 function isUserConfigPath(workspacePath) {
   const projectConfigPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
   const userConfigPath = getUserWorkspaceConfigPath();
-  return resolve5(projectConfigPath) === resolve5(userConfigPath);
+  return resolve6(projectConfigPath) === resolve6(userConfigPath);
 }
 async function ensureUserWorkspace() {
   const configPath = getUserWorkspaceConfigPath();
@@ -25494,9 +25581,9 @@ async function ensureUserWorkspace() {
   const defaultConfig = {
     repositories: [],
     plugins: [],
-    clients: [...ALL_CLIENTS]
+    clients: [...DEFAULT_USER_CLIENTS]
   };
-  await mkdir3(getAllagentsDir(), { recursive: true });
+  await mkdir4(getAllagentsDir(), { recursive: true });
   await writeFile2(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
 }
 async function getUserWorkspaceConfig() {
@@ -25662,7 +25749,51 @@ async function addPluginToUserConfig(plugin, configPath, autoRegistered) {
     };
   }
 }
-var ALL_CLIENTS;
+async function getInstalledUserPlugins() {
+  const config = await getUserWorkspaceConfig();
+  if (!config)
+    return [];
+  const result = [];
+  for (const plugin of config.plugins) {
+    const parsed = parsePluginSpec(plugin);
+    if (parsed) {
+      result.push({
+        spec: plugin,
+        name: parsed.plugin,
+        marketplace: parsed.marketplaceName,
+        scope: "user"
+      });
+    }
+  }
+  return result;
+}
+async function getInstalledProjectPlugins(workspacePath) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync6(configPath))
+    return [];
+  try {
+    const content = await readFile6(configPath, "utf-8");
+    const config = load(content);
+    if (!config?.plugins)
+      return [];
+    const result = [];
+    for (const plugin of config.plugins) {
+      const parsed = parsePluginSpec(plugin);
+      if (parsed) {
+        result.push({
+          spec: plugin,
+          name: parsed.plugin,
+          marketplace: parsed.marketplaceName,
+          scope: "project"
+        });
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+var DEFAULT_USER_CLIENTS;
 var init_user_workspace = __esm(() => {
   init_js_yaml();
   init_constants();
@@ -25670,8 +25801,7 @@ var init_user_workspace = __esm(() => {
   init_marketplace();
   init_plugin_path();
   init_marketplace_manifest_parser();
-  ALL_CLIENTS = [
-    "claude",
+  DEFAULT_USER_CLIENTS = [
     "copilot",
     "codex",
     "cursor",
@@ -25683,16 +25813,16 @@ var init_user_workspace = __esm(() => {
 });
 
 // src/core/marketplace.ts
-import { mkdir as mkdir4, readFile as readFile7, readdir as readdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, readdir as readdir3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
-import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
+import { basename as basename2, join as join9, resolve as resolve7 } from "node:path";
 function parseLocation(location) {
   const [owner = "", repo = "", ...rest] = location.split("/");
   const branch = rest.length > 0 ? rest.join("/") : undefined;
   return { owner, repo, ...branch !== undefined && { branch } };
 }
 function getAllagentsDir() {
-  return resolve6(getHomeDir(), ".allagents");
+  return resolve7(getHomeDir(), ".allagents");
 }
 function getMarketplacesDir() {
   return join9(getAllagentsDir(), "plugins", "marketplaces");
@@ -25716,7 +25846,7 @@ async function saveRegistry(registry) {
   const registryPath = getRegistryPath();
   const dir = getAllagentsDir();
   if (!existsSync7(dir)) {
-    await mkdir4(dir, { recursive: true });
+    await mkdir5(dir, { recursive: true });
   }
   await writeFile3(registryPath, `${JSON.stringify(registry, null, 2)}
 `);
@@ -25746,7 +25876,7 @@ function parseMarketplaceSource(source) {
     return null;
   }
   if (source.startsWith("/") || source.startsWith(".")) {
-    const absPath = resolve6(source);
+    const absPath = resolve7(source);
     const name = basename2(absPath) || "local";
     return {
       type: "local",
@@ -25806,7 +25936,7 @@ async function addMarketplace(source, customName, branch) {
     if (existsSync7(marketplacePath)) {} else {
       const parentDir = getMarketplacesDir();
       if (!existsSync7(parentDir)) {
-        await mkdir4(parentDir, { recursive: true });
+        await mkdir5(parentDir, { recursive: true });
       }
       const { owner, repo } = parseLocation(parsed.location);
       const repoUrl = gitHubUrl(owner, repo);
@@ -25894,6 +26024,9 @@ async function removeMarketplace(name) {
   const entry = registry.marketplaces[name];
   delete registry.marketplaces[name];
   await saveRegistry(registry);
+  if (existsSync7(entry.path)) {
+    await rm3(entry.path, { recursive: true, force: true });
+  }
   const { removeUserPluginsForMarketplace: removeUserPluginsForMarketplace2 } = await Promise.resolve().then(() => (init_user_workspace(), exports_user_workspace));
   const removedUserPlugins = await removeUserPluginsForMarketplace2(name);
   return {
@@ -25997,7 +26130,7 @@ async function getMarketplacePluginsFromManifest(marketplacePath) {
     const resolvedSource = resolvePluginSourcePath(plugin.source, marketplacePath);
     const info = {
       name: plugin.name,
-      path: typeof plugin.source === "string" ? resolve6(marketplacePath, plugin.source) : resolvedSource,
+      path: typeof plugin.source === "string" ? resolve7(marketplacePath, plugin.source) : resolvedSource,
       description: plugin.description,
       source: resolvedSource
     };
@@ -26082,7 +26215,7 @@ async function resolvePluginSpec(spec, options2 = {}) {
     const pluginEntry = manifestResult.data.plugins.find((p) => p.name === parsed.plugin);
     if (pluginEntry) {
       if (typeof pluginEntry.source === "string") {
-        const resolvedPath = resolve6(marketplacePath, pluginEntry.source);
+        const resolvedPath = resolve7(marketplacePath, pluginEntry.source);
         if (existsSync7(resolvedPath)) {
           return {
             path: resolvedPath,
@@ -26137,7 +26270,7 @@ async function refreshMarketplace(marketplace) {
   delete registry.marketplaces[marketplace.name];
   await saveRegistry(registry);
   if (existsSync7(marketplace.path)) {
-    await rm2(marketplace.path, { recursive: true, force: true });
+    await rm3(marketplace.path, { recursive: true, force: true });
   }
   return addMarketplace(`${owner}/${repo}`, marketplace.name, branch);
 }
@@ -26243,6 +26376,18 @@ function isPluginSpec(spec) {
 function getWellKnownMarketplaces() {
   return { ...WELL_KNOWN_MARKETPLACES };
 }
+async function getMarketplaceVersion(marketplacePath) {
+  if (!existsSync7(marketplacePath)) {
+    return null;
+  }
+  try {
+    const git = esm_default(marketplacePath);
+    const log = await git.log({ maxCount: 1, format: { hash: "%h" } });
+    return log.latest?.hash || null;
+  } catch {
+    return null;
+  }
+}
 var WELL_KNOWN_MARKETPLACES;
 var init_marketplace = __esm(() => {
   init_esm();
@@ -26257,7 +26402,7 @@ var init_marketplace = __esm(() => {
 });
 
 // src/core/workspace-modify.ts
-import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir5 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir6 } from "node:fs/promises";
 import { existsSync as existsSync8 } from "node:fs";
 import { join as join10 } from "node:path";
 async function setClients(clients, workspacePath = process.cwd()) {
@@ -26291,7 +26436,7 @@ async function ensureWorkspace(workspacePath) {
     plugins: [],
     clients: [...DEFAULT_PROJECT_CLIENTS]
   };
-  await mkdir5(configDir, { recursive: true });
+  await mkdir6(configDir, { recursive: true });
   await writeFile4(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
 }
 async function addPlugin(plugin, workspacePath = process.cwd()) {
@@ -26711,9 +26856,9 @@ var init_sync_state = __esm(() => {
 });
 
 // src/core/sync-state.ts
-import { readFile as readFile10, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join12, dirname as dirname3 } from "node:path";
+import { join as join12, dirname as dirname4 } from "node:path";
 function getSyncStatePath(workspacePath) {
   return join12(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
 }
@@ -26741,7 +26886,7 @@ async function saveSyncState(workspacePath, files) {
     lastSync: new Date().toISOString(),
     files
   };
-  await mkdir6(dirname3(statePath), { recursive: true });
+  await mkdir7(dirname4(statePath), { recursive: true });
   await writeFile6(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function getPreviouslySyncedFiles(state, client) {
@@ -26756,11 +26901,11 @@ var init_sync_state2 = __esm(() => {
 });
 
 // src/core/vscode-workspace.ts
-import { resolve as resolve7, basename as basename3, isAbsolute as isAbsolute2 } from "node:path";
+import { resolve as resolve8, basename as basename3, isAbsolute as isAbsolute2 } from "node:path";
 function buildPathPlaceholderMap(repositories, workspacePath) {
   const map2 = new Map;
   for (const repo of repositories) {
-    const absolutePath = resolve7(workspacePath, repo.path);
+    const absolutePath = resolve8(workspacePath, repo.path);
     map2.set(repo.path, absolutePath);
   }
   return map2;
@@ -26795,16 +26940,16 @@ function generateVscodeWorkspace(input) {
   const folders = [];
   const seenPaths = new Set;
   folders.push({ path: "." });
-  seenPaths.add(resolve7(workspacePath, "."));
+  seenPaths.add(resolve8(workspacePath, "."));
   for (const repo of repositories) {
-    const absolutePath = resolve7(workspacePath, repo.path).replace(/\\/g, "/");
+    const absolutePath = resolve8(workspacePath, repo.path).replace(/\\/g, "/");
     folders.push({ path: absolutePath });
     seenPaths.add(absolutePath);
   }
   if (resolvedTemplate && Array.isArray(resolvedTemplate.folders)) {
     for (const folder of resolvedTemplate.folders) {
       const rawPath = folder.path;
-      const normalizedPath = (typeof rawPath === "string" && !isAbsolute2(rawPath) ? resolve7(workspacePath, rawPath) : rawPath).replace(/\\/g, "/");
+      const normalizedPath = (typeof rawPath === "string" && !isAbsolute2(rawPath) ? resolve8(workspacePath, rawPath) : rawPath).replace(/\\/g, "/");
       if (!seenPaths.has(normalizedPath)) {
         const entry = { path: normalizedPath };
         if (folder.name)
@@ -26834,10 +26979,10 @@ function getWorkspaceOutputPath(workspacePath, vscodeConfig) {
   const name = vscodeConfig?.output;
   if (name) {
     const filename = name.endsWith(".code-workspace") ? name : `${name}.code-workspace`;
-    return resolve7(workspacePath, filename);
+    return resolve8(workspacePath, filename);
   }
-  const dirName = basename3(resolve7(workspacePath));
-  return resolve7(workspacePath, `${dirName}.code-workspace`);
+  const dirName = basename3(resolve8(workspacePath));
+  return resolve8(workspacePath, `${dirName}.code-workspace`);
 }
 var DEFAULT_SETTINGS;
 var init_vscode_workspace = __esm(() => {
@@ -26847,9 +26992,9 @@ var init_vscode_workspace = __esm(() => {
 });
 
 // src/core/sync.ts
-import { existsSync as existsSync11, readFileSync, writeFileSync } from "node:fs";
-import { rm as rm3, unlink, rmdir, copyFile } from "node:fs/promises";
-import { join as join13, resolve as resolve8, dirname as dirname4, relative } from "node:path";
+import { existsSync as existsSync11, readFileSync, writeFileSync, lstatSync } from "node:fs";
+import { rm as rm4, unlink, rmdir, copyFile } from "node:fs/promises";
+import { join as join13, resolve as resolve9, dirname as dirname5, relative as relative2 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -26900,8 +27045,11 @@ async function selectivePurgeWorkspace(workspacePath, state, clients, options2)
         continue;
       }
       try {
-        if (filePath.endsWith("/")) {
-          await rm3(fullPath, { recursive: true, force: true });
+        const stats = lstatSync(fullPath.replace(/\/$/, ""));
+        if (stats.isSymbolicLink()) {
+          await unlink(fullPath.replace(/\/$/, ""));
+        } else if (filePath.endsWith("/")) {
+          await rm4(fullPath, { recursive: true, force: true });
         } else {
           await unlink(fullPath);
         }
@@ -26916,16 +27064,16 @@ async function selectivePurgeWorkspace(workspacePath, state, clients, options2)
   return result;
 }
 async function cleanupEmptyParents(workspacePath, filePath) {
-  let parentPath = dirname4(filePath);
+  let parentPath = dirname5(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
     const fullParentPath = join13(workspacePath, parentPath);
     if (!existsSync11(fullParentPath)) {
-      parentPath = dirname4(parentPath);
+      parentPath = dirname5(parentPath);
       continue;
     }
     try {
       await rmdir(fullParentPath);
-      parentPath = dirname4(parentPath);
+      parentPath = dirname5(parentPath);
     } catch {
       break;
     }
@@ -27032,11 +27180,11 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         if (file.source.startsWith("/")) {
           fullPath = file.source;
         } else if (file.source.startsWith("../")) {
-          fullPath = resolve8(file.source);
+          fullPath = resolve9(file.source);
         } else if (defaultSourcePath) {
           fullPath = join13(defaultSourcePath, file.source);
         } else {
-          fullPath = resolve8(file.source);
+          fullPath = resolve9(file.source);
         }
         if (!existsSync11(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
@@ -27065,7 +27213,7 @@ function collectSyncedPaths(copyResults, workspacePath, clients, clientMappings)
     if (copyResult.action !== "copied" && copyResult.action !== "generated") {
       continue;
     }
-    const relativePath = relative(workspacePath, copyResult.destination).replace(/\\/g, "/");
+    const relativePath = relative2(workspacePath, copyResult.destination).replace(/\\/g, "/");
     for (const client of clients) {
       const mapping = mappings[client];
       if (mapping.skillsPath && relativePath.startsWith(mapping.skillsPath)) {
@@ -27121,7 +27269,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
       success: true
     };
   }
-  const resolvedPath = resolve8(workspacePath, pluginSource);
+  const resolvedPath = resolve9(workspacePath, pluginSource);
   if (!existsSync11(resolvedPath)) {
     return {
       plugin: pluginSource,
@@ -27139,13 +27287,55 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
 async function validateAllPlugins(plugins, workspacePath, offline) {
   return Promise.all(plugins.map((plugin) => validatePlugin(plugin, workspacePath, offline)));
 }
-async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, clientMappings) {
+async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, clientMappings, syncMode = "symlink") {
   const copyResults = [];
   const mappings = clientMappings ?? CLIENT_MAPPINGS;
-  const { representativeClients } = deduplicateClientsByPath(clients, mappings);
-  for (const client of representativeClients) {
-    const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, { dryRun, ...skillNameMap && { skillNameMap }, ...clientMappings && { clientMappings } });
-    copyResults.push(...results);
+  const clientList = clients;
+  if (syncMode === "symlink") {
+    const { representativeClients } = deduplicateClientsByPath(clientList, mappings);
+    const canonicalRepresentative = representativeClients.find((c) => mappings[c]?.skillsPath === CANONICAL_SKILLS_PATH);
+    const needsCanonicalCopy = !canonicalRepresentative;
+    const nonUniversalClients = clientList.filter((c) => !isUniversalClient(c));
+    if (needsCanonicalCopy && nonUniversalClients.length > 0) {
+      const canonicalResults = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, "copilot", {
+        dryRun,
+        ...skillNameMap && { skillNameMap },
+        syncMode: "copy"
+      });
+      const skillResults = canonicalResults.filter((r) => r.destination.includes(CANONICAL_SKILLS_PATH) && r.action === "copied");
+      copyResults.push(...skillResults);
+    }
+    for (const representative of representativeClients) {
+      if (isUniversalClient(representative)) {
+        const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, representative, {
+          dryRun,
+          ...skillNameMap && { skillNameMap },
+          ...clientMappings && { clientMappings },
+          syncMode: "copy"
+        });
+        copyResults.push(...results);
+      } else {
+        const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, representative, {
+          dryRun,
+          ...skillNameMap && { skillNameMap },
+          ...clientMappings && { clientMappings },
+          syncMode: "symlink",
+          canonicalSkillsPath: CANONICAL_SKILLS_PATH
+        });
+        copyResults.push(...results);
+      }
+    }
+  } else {
+    const { representativeClients } = deduplicateClientsByPath(clientList, mappings);
+    for (const client of representativeClients) {
+      const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, {
+        dryRun,
+        ...skillNameMap && { skillNameMap },
+        ...clientMappings && { clientMappings },
+        syncMode: "copy"
+      });
+      copyResults.push(...results);
+    }
   }
   const hasFailures = copyResults.some((r) => r.action === "failed");
   return {
@@ -27309,9 +27499,10 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   const allSkills = await collectAllSkills(validPlugins);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
+  const syncMode = config.syncMode ?? "symlink";
   const pluginResults = await Promise.all(validPlugins.map((validatedPlugin) => {
     const skillNameMap = pluginSkillMaps.get(validatedPlugin.resolved);
-    return copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap);
+    return copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, undefined, syncMode);
   }));
   let workspaceFileResults = [];
   if (config.workspace) {
@@ -27437,7 +27628,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   };
 }
 async function syncUserWorkspace(options2 = {}) {
-  const homeDir = resolve8(getHomeDir());
+  const homeDir = resolve9(getHomeDir());
   const config = await getUserWorkspaceConfig();
   if (!config) {
     return {
@@ -27475,9 +27666,10 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   const allSkills = await collectAllSkills(validPlugins);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
+  const syncMode = config.syncMode ?? "symlink";
   const pluginResults = await Promise.all(validPlugins.map((vp) => {
     const skillNameMap = pluginSkillMaps.get(vp.resolved);
-    return copyValidatedPlugin(vp, homeDir, clients, dryRun, skillNameMap, USER_CLIENT_MAPPINGS);
+    return copyValidatedPlugin(vp, homeDir, clients, dryRun, skillNameMap, USER_CLIENT_MAPPINGS, syncMode);
   }));
   let totalCopied = 0;
   let totalFailed = 0;
@@ -27631,12 +27823,12 @@ var init_github_fetch = __esm(() => {
 });
 
 // src/core/workspace.ts
-import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile7, copyFile as copyFile2 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile7, copyFile as copyFile2 } from "node:fs/promises";
 import { existsSync as existsSync13 } from "node:fs";
-import { join as join15, resolve as resolve9, dirname as dirname5, relative as relative2, sep as sep2, isAbsolute as isAbsolute3 } from "node:path";
+import { join as join15, resolve as resolve10, dirname as dirname6, relative as relative3, sep as sep2, isAbsolute as isAbsolute3 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
-  const absoluteTarget = resolve9(targetPath);
+  const absoluteTarget = resolve10(targetPath);
   const configDir = join15(absoluteTarget, CONFIG_DIR);
   const configPath = join15(configDir, WORKSPACE_CONFIG_FILE);
   if (existsSync13(configPath)) {
@@ -27644,13 +27836,13 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   Found existing ${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`);
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentFileDir = dirname5(currentFilePath);
+  const currentFileDir = dirname6(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
   const defaultTemplatePath = isProduction ? join15(currentFileDir, "templates", "default") : join15(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   try {
-    await mkdir7(absoluteTarget, { recursive: true });
-    await mkdir7(configDir, { recursive: true });
+    await mkdir8(absoluteTarget, { recursive: true });
+    await mkdir8(configDir, { recursive: true });
     let workspaceYamlContent;
     let sourceDir;
     if (options2.from) {
@@ -27682,7 +27874,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
-        const fromPath = resolve9(options2.from);
+        const fromPath = resolve10(options2.from);
         if (!existsSync13(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
@@ -27704,9 +27896,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else {
           sourceYamlPath = fromPath;
-          const parentDir = dirname5(fromPath);
+          const parentDir = dirname6(fromPath);
           if (parentDir.endsWith(CONFIG_DIR)) {
-            sourceDir = dirname5(parentDir);
+            sourceDir = dirname6(parentDir);
           } else {
             sourceDir = parentDir;
           }
@@ -27718,7 +27910,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           if (workspace?.source) {
             const source = workspace.source;
             if (!isGitHubUrl(source) && !isAbsolute3(source)) {
-              workspace.source = resolve9(sourceDir, source);
+              workspace.source = resolve10(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
           }
@@ -27834,7 +28026,7 @@ Syncing plugins...`);
     if (targetPath !== ".") {
       console.log(`
 Next steps:`);
-      console.log(`  cd ${relative2(process.cwd(), absoluteTarget)}`);
+      console.log(`  cd ${relative3(process.cwd(), absoluteTarget)}`);
     }
     return {
       path: absoluteTarget,
@@ -28045,12 +28237,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve11, reject) {
+      return new Promise(function(resolve12, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve11(is);
+            resolve12(is);
           }
         });
       });
@@ -28112,27 +28304,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve11, reject) => {
+    const step = (i2) => new Promise((resolve12, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve11(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve12(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve11(subStep(p, i2, 0));
+      resolve12(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve11, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve12, reject) => {
       if (ii === pathExt.length)
-        return resolve11(step(i2 + 1));
+        return resolve12(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve11(p + ext);
+            return resolve12(p + ext);
         }
-        return resolve11(subStep(p, i2, ii + 1));
+        return resolve12(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -28173,8 +28365,8 @@ var require_which = __commonJS((exports, module) => {
 var require_path_key = __commonJS((exports, module) => {
   var pathKey = (options2 = {}) => {
     const environment = options2.env || process.env;
-    const platform = options2.platform || process.platform;
-    if (platform !== "win32") {
+    const platform2 = options2.platform || process.platform;
+    if (platform2 !== "win32") {
       return "PATH";
     }
     return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
@@ -28431,9 +28623,9 @@ function stripFinalNewline(input) {
 function pathKey(options2 = {}) {
   const {
     env: env2 = process.env,
-    platform = process.platform
+    platform: platform2 = process.platform
   } = options2;
-  if (platform !== "win32") {
+  if (platform2 !== "win32") {
     return "PATH";
   }
   return Object.keys(env2).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
@@ -29265,7 +29457,7 @@ var DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill = (kill, signal = "SIGTERM", options
     return spawnedPromise;
   }
   let timeoutId;
-  const timeoutPromise = new Promise((resolve11, reject) => {
+  const timeoutPromise = new Promise((resolve12, reject) => {
     timeoutId = setTimeout(() => {
       timeoutKill(spawned, killSignal, reject);
     }, timeout);
@@ -29655,9 +29847,9 @@ var nativePromisePrototype, descriptors, mergePromise = (spawned, promise) => {
     const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
     Reflect.defineProperty(spawned, property, { ...descriptor, value });
   }
-}, getSpawnedPromise = (spawned) => new Promise((resolve11, reject) => {
+}, getSpawnedPromise = (spawned) => new Promise((resolve12, reject) => {
   spawned.on("exit", (exitCode, signal) => {
-    resolve11({ exitCode, signal });
+    resolve12({ exitCode, signal });
   });
   spawned.on("error", (error) => {
     reject(error);
@@ -29973,7 +30165,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "0.17.2",
+    version: "0.19.1",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -32563,7 +32755,7 @@ __export(exports_wizard, {
   runWizard: () => runWizard,
   buildMenuOptions: () => buildMenuOptions
 });
-import { relative as relative3 } from "node:path";
+import { relative as relative4 } from "node:path";
 function buildMenuOptions(context) {
   const options2 = [];
   if (!context.hasWorkspace) {
@@ -32598,7 +32790,7 @@ function buildMenuOptions(context) {
 function buildSummary(context) {
   const lines = [];
   if (context.hasWorkspace && context.workspacePath) {
-    const relPath = relative3(process.cwd(), context.workspacePath) || ".";
+    const relPath = relative4(process.cwd(), context.workspacePath) || ".";
     lines.push(`Workspace: ${relPath}`);
     lines.push(`Project plugins: ${context.projectPluginCount}`);
   } else {
@@ -32737,7 +32929,7 @@ init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
 import { existsSync as existsSync16 } from "node:fs";
-import { join as join18, resolve as resolve10 } from "node:path";
+import { join as join18, resolve as resolve11 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -33304,7 +33496,7 @@ var repoAddCmd = import_cmd_ts2.command({
   },
   handler: async ({ path: repoPath, description }) => {
     try {
-      const resolvedPath = resolve10(process.cwd(), repoPath);
+      const resolvedPath = resolve11(process.cwd(), repoPath);
       const remote = await detectRemote(resolvedPath);
       const result = await addRepository(repoPath, {
         source: remote?.source,
@@ -33877,14 +34069,13 @@ var marketplaceRemoveCmd = import_cmd_ts3.command({
         });
         return;
       }
-      console.log(`✓ Marketplace '${name}' removed from registry`);
+      console.log(`✓ Marketplace '${name}' removed`);
       if (result.removedUserPlugins && result.removedUserPlugins.length > 0) {
         console.log(`  Removed ${result.removedUserPlugins.length} user plugin(s):`);
         for (const p of result.removedUserPlugins) {
           console.log(`    - ${p}`);
         }
       }
-      console.log(`  Note: Files at ${result.marketplace?.path} were not deleted`);
     } catch (error) {
       if (error instanceof Error) {
         if (isJsonMode()) {
@@ -34001,13 +34192,36 @@ var pluginListCmd = import_cmd_ts3.command({
         console.error(`Marketplace '${marketplace}' not found`);
         process.exit(1);
       }
+      const userPlugins = await getInstalledUserPlugins();
+      const projectPlugins = await getInstalledProjectPlugins(process.cwd());
+      const installedMap = new Map;
+      for (const p of userPlugins) {
+        installedMap.set(`${p.name}@${p.marketplace}`, p);
+      }
+      for (const p of projectPlugins) {
+        installedMap.set(`${p.name}@${p.marketplace}`, p);
+      }
+      const versionMap = new Map;
+      for (const mp of toList) {
+        const version = await getMarketplaceVersion(mp.path);
+        versionMap.set(mp.name, version);
+      }
       if (isJsonMode()) {
         const allPlugins = [];
         const allWarnings = [];
         for (const mp of toList) {
           const result = await listMarketplacePlugins(mp.name);
+          const version = versionMap.get(mp.name) ?? null;
           for (const plugin of result.plugins) {
-            allPlugins.push({ name: plugin.name, marketplace: mp.name });
+            const key = `${plugin.name}@${mp.name}`;
+            const installed = installedMap.get(key);
+            allPlugins.push({
+              name: plugin.name,
+              marketplace: mp.name,
+              version,
+              scope: installed?.scope ?? null,
+              enabled: !!installed
+            });
           }
           for (const warning of result.warnings) {
             allWarnings.push(`${mp.name}: ${warning}`);
@@ -34025,29 +34239,52 @@ var pluginListCmd = import_cmd_ts3.command({
         return;
       }
       let totalPlugins = 0;
+      const allPluginEntries = [];
       for (const mp of toList) {
         const result = await listMarketplacePlugins(mp.name);
-        if (result.plugins.length === 0 && result.warnings.length === 0) {
-          console.log(`${mp.name}: (no plugins found)`);
-          continue;
-        }
-        console.log(`${mp.name}:`);
+        const version = versionMap.get(mp.name) ?? null;
         for (const warning of result.warnings) {
-          console.log(`  Warning: ${warning}`);
-        }
-        if (result.plugins.length === 0) {
-          console.log("  (no plugins found)");
+          allPluginEntries.push({
+            name: "",
+            marketplace: mp.name,
+            version,
+            installed: undefined,
+            warning
+          });
         }
         for (const plugin of result.plugins) {
-          console.log(`  - ${plugin.name}@${mp.name}`);
+          const key = `${plugin.name}@${mp.name}`;
+          const installed = installedMap.get(key);
+          allPluginEntries.push({
+            name: plugin.name,
+            marketplace: mp.name,
+            version,
+            installed
+          });
           totalPlugins++;
         }
-        console.log();
       }
       if (totalPlugins === 0) {
         console.log("No plugins found in registered marketplaces.");
-      } else {
-        console.log(`Total: ${totalPlugins} plugin(s)`);
+        return;
+      }
+      console.log(`Installed plugins:
+`);
+      for (const entry of allPluginEntries) {
+        if (entry.warning) {
+          console.log(`  Warning: ${entry.warning}`);
+          continue;
+        }
+        const isEnabled = !!entry.installed;
+        const statusIcon = isEnabled ? "✓" : "✗";
+        const statusText = isEnabled ? "enabled" : "disabled";
+        console.log(`  ❯ ${entry.name}@${entry.marketplace}`);
+        console.log(`    Version: ${entry.version ?? "unknown"}`);
+        if (entry.installed) {
+          console.log(`    Scope: ${entry.installed.scope}`);
+        }
+        console.log(`    Status: ${statusIcon} ${statusText}`);
+        console.log();
       }
     } catch (error) {
       if (error instanceof Error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "0.17.2",
+  "version": "0.19.1",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {