allagents 0.7.0 → 0.7.2

package/README.md

@@ -66,9 +66,9 @@ allagents workspace init my-workspace --from owner/repo/path/to/template
 # Add a marketplace (or let auto-registration handle it)
 allagents plugin marketplace add anthropics/claude-plugins-official
 
-# Add plugins to workspace
-allagents workspace plugin add code-review@claude-plugins-official
-allagents workspace plugin add my-plugin@someuser/their-repo
+# Install plugins to workspace
+allagents workspace plugin install code-review@claude-plugins-official
+allagents workspace plugin install my-plugin@someuser/their-repo
 
 # Sync plugins to workspace
 allagents workspace sync
@@ -113,8 +113,8 @@ allagents workspace sync [options]
 # Show status of workspace and plugins
 allagents workspace status
 
-# Add a plugin to .allagents/workspace.yaml (auto-registers marketplace if needed)
-allagents workspace plugin add <plugin@marketplace>
+# Install a plugin to .allagents/workspace.yaml (auto-registers marketplace if needed)
+allagents workspace plugin install <plugin@marketplace>
 
 # Remove a plugin from .allagents/workspace.yaml
 allagents workspace plugin remove <plugin>

package/dist/index.js

@@ -11055,13 +11055,13 @@ var {
 
 // src/cli/index.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
+import { dirname as dirname7, join as join13 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/core/workspace.ts
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile4, copyFile as copyFile2 } from "node:fs/promises";
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join8, resolve as resolve5, dirname as dirname5, relative as relative2, sep, isAbsolute as isAbsolute2 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile4, copyFile as copyFile2 } from "node:fs/promises";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join9, resolve as resolve6, dirname as dirname5, relative as relative2, sep, isAbsolute as isAbsolute2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -13712,9 +13712,9 @@ var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
 // src/core/sync.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { rm, unlink, rmdir, copyFile } from "node:fs/promises";
-import { join as join7, resolve as resolve4, dirname as dirname4, relative } from "node:path";
+import { join as join8, resolve as resolve5, dirname as dirname4, relative } from "node:path";
 
 // src/constants.ts
 var CONFIG_DIR = ".allagents";
@@ -19787,11 +19787,10 @@ import { existsSync as existsSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 
 // src/models/skill-metadata.ts
-var skillNameRegex = /^[a-z0-9-]{1,64}$/;
 var SkillMetadataSchema = exports_external.object({
-  name: exports_external.string().regex(skillNameRegex, "Skill name must be lowercase, alphanumeric + hyphens, max 64 chars"),
+  name: exports_external.string().min(1, "Skill name is required").max(128, "Skill name too long"),
   description: exports_external.string().min(1, "Description is required"),
-  "allowed-tools": exports_external.array(exports_external.string()).optional(),
+  "allowed-tools": exports_external.union([exports_external.array(exports_external.string()), exports_external.string().transform((s) => [s])]).optional(),
   model: exports_external.string().optional()
 });
 
@@ -20413,29 +20412,120 @@ function resolveSkillNames(skills) {
 }
 
 // src/core/marketplace.ts
-import { mkdir as mkdir3, readFile as readFile5, readdir as readdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile6, readdir as readdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync5 } from "node:fs";
+import { basename as basename2, join as join6, resolve as resolve4 } from "node:path";
+
+// src/utils/marketplace-manifest-parser.ts
+import { readFile as readFile5 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import { basename as basename2, join as join5, resolve as resolve3 } from "node:path";
+import { join as join5, resolve as resolve3 } from "node:path";
+
+// src/models/marketplace-manifest.ts
+var UrlSourceSchema = exports_external.object({
+  source: exports_external.literal("url"),
+  url: exports_external.string().url()
+});
+var PluginSourceRefSchema = exports_external.union([exports_external.string(), UrlSourceSchema]);
+var ContactSchema = exports_external.object({
+  name: exports_external.string(),
+  email: exports_external.string().optional()
+});
+var LspServerSchema = exports_external.object({
+  command: exports_external.string(),
+  args: exports_external.array(exports_external.string()).optional(),
+  extensionToLanguage: exports_external.record(exports_external.string()).optional(),
+  startupTimeout: exports_external.number().optional()
+});
+var MarketplacePluginEntrySchema = exports_external.object({
+  name: exports_external.string().min(1),
+  description: exports_external.string().min(1),
+  source: PluginSourceRefSchema,
+  version: exports_external.string().optional(),
+  author: ContactSchema.optional(),
+  category: exports_external.string().optional(),
+  homepage: exports_external.string().optional(),
+  strict: exports_external.boolean().optional(),
+  tags: exports_external.array(exports_external.string()).optional(),
+  lspServers: exports_external.record(LspServerSchema).optional()
+});
+var MarketplaceManifestSchema = exports_external.object({
+  $schema: exports_external.string().optional(),
+  name: exports_external.string().min(1),
+  version: exports_external.string().optional(),
+  description: exports_external.string().min(1),
+  owner: ContactSchema.optional(),
+  plugins: exports_external.array(MarketplacePluginEntrySchema)
+});
+
+// src/utils/marketplace-manifest-parser.ts
+var MANIFEST_PATH = ".claude-plugin/marketplace.json";
+async function parseMarketplaceManifest(marketplacePath) {
+  const manifestPath = join5(marketplacePath, MANIFEST_PATH);
+  if (!existsSync4(manifestPath)) {
+    return {
+      success: false,
+      error: `Marketplace manifest not found: ${manifestPath}`
+    };
+  }
+  let raw;
+  try {
+    raw = await readFile5(manifestPath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read marketplace manifest: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let json2;
+  try {
+    json2 = JSON.parse(raw);
+  } catch {
+    return {
+      success: false,
+      error: "Failed to parse marketplace.json as JSON: invalid syntax"
+    };
+  }
+  const result = MarketplaceManifestSchema.safeParse(json2);
+  if (!result.success) {
+    const issues = result.error.issues.map((i2) => `  ${i2.path.join(".")}: ${i2.message}`).join(`
+`);
+    return {
+      success: false,
+      error: `Marketplace manifest validation failed:
+${issues}`
+    };
+  }
+  return { success: true, data: result.data };
+}
+function resolvePluginSourcePath(source, marketplacePath) {
+  if (typeof source === "object") {
+    return source.url;
+  }
+  return resolve3(marketplacePath, source);
+}
+
+// src/core/marketplace.ts
 var WELL_KNOWN_MARKETPLACES = {
   "claude-plugins-official": "anthropics/claude-plugins-official"
 };
 function getAllagentsDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
-  return resolve3(homeDir, ".allagents");
+  return resolve4(homeDir, ".allagents");
 }
 function getMarketplacesDir() {
-  return join5(getAllagentsDir(), "marketplaces");
+  return join6(getAllagentsDir(), "marketplaces");
 }
 function getRegistryPath() {
-  return join5(getAllagentsDir(), "marketplaces.json");
+  return join6(getAllagentsDir(), "marketplaces.json");
 }
 async function loadRegistry() {
   const registryPath = getRegistryPath();
-  if (!existsSync4(registryPath)) {
+  if (!existsSync5(registryPath)) {
     return { version: 1, marketplaces: {} };
   }
   try {
-    const content = await readFile5(registryPath, "utf-8");
+    const content = await readFile6(registryPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, marketplaces: {} };
@@ -20444,7 +20534,7 @@ async function loadRegistry() {
 async function saveRegistry(registry) {
   const registryPath = getRegistryPath();
   const dir = getAllagentsDir();
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     await mkdir3(dir, { recursive: true });
   }
   await writeFile2(registryPath, `${JSON.stringify(registry, null, 2)}
@@ -20473,7 +20563,7 @@ function parseMarketplaceSource(source) {
     return null;
   }
   if (source.startsWith("/") || source.startsWith(".")) {
-    const absPath = resolve3(source);
+    const absPath = resolve4(source);
     const name = basename2(absPath) || "local";
     return {
       type: "local",
@@ -20502,7 +20592,7 @@ async function addMarketplace(source, customName) {
   Use: GitHub URL, owner/repo, local path, or well-known name`
     };
   }
-  const name = customName || parsed.name;
+  let name = customName || parsed.name;
   const registry = await loadRegistry();
   if (registry.marketplaces[name]) {
     return {
@@ -20512,8 +20602,8 @@ async function addMarketplace(source, customName) {
   }
   let marketplacePath;
   if (parsed.type === "github") {
-    marketplacePath = join5(getMarketplacesDir(), name);
-    if (existsSync4(marketplacePath)) {} else {
+    marketplacePath = join6(getMarketplacesDir(), name);
+    if (existsSync5(marketplacePath)) {} else {
       try {
         await execa("gh", ["--version"]);
       } catch {
@@ -20524,7 +20614,7 @@ async function addMarketplace(source, customName) {
         };
       }
       const parentDir = getMarketplacesDir();
-      if (!existsSync4(parentDir)) {
+      if (!existsSync5(parentDir)) {
         await mkdir3(parentDir, { recursive: true });
       }
       try {
@@ -20545,13 +20635,29 @@ async function addMarketplace(source, customName) {
     }
   } else {
     marketplacePath = parsed.location;
-    if (!existsSync4(marketplacePath)) {
+    if (!existsSync5(marketplacePath)) {
       return {
         success: false,
         error: `Local directory not found: ${marketplacePath}`
       };
     }
   }
+  if (!customName) {
+    const manifestResult = await parseMarketplaceManifest(marketplacePath);
+    if (manifestResult.success && manifestResult.data.name) {
+      const manifestName = manifestResult.data.name;
+      if (manifestName !== name) {
+        const existing = registry.marketplaces[manifestName];
+        if (existing) {
+          return {
+            success: true,
+            marketplace: existing
+          };
+        }
+        name = manifestName;
+      }
+    }
+  }
   const entry = {
     name,
     source: {
@@ -20607,7 +20713,7 @@ async function updateMarketplace(name) {
       });
       continue;
     }
-    if (!existsSync4(marketplace.path)) {
+    if (!existsSync5(marketplace.path)) {
       results.push({
         name: marketplace.name,
         success: false,
@@ -20634,20 +20740,44 @@ async function updateMarketplace(name) {
   await saveRegistry(registry);
   return results;
 }
+async function getMarketplacePluginsFromManifest(marketplacePath) {
+  const result = await parseMarketplaceManifest(marketplacePath);
+  if (!result.success) {
+    return [];
+  }
+  return result.data.plugins.map((plugin) => {
+    const resolvedSource = resolvePluginSourcePath(plugin.source, marketplacePath);
+    const info = {
+      name: plugin.name,
+      path: typeof plugin.source === "string" ? resolve4(marketplacePath, plugin.source) : resolvedSource,
+      description: plugin.description,
+      source: resolvedSource
+    };
+    if (plugin.category)
+      info.category = plugin.category;
+    if (plugin.homepage)
+      info.homepage = plugin.homepage;
+    return info;
+  });
+}
 async function listMarketplacePlugins(name) {
   const marketplace = await getMarketplace(name);
   if (!marketplace) {
     return [];
   }
-  const pluginsDir = join5(marketplace.path, "plugins");
-  if (!existsSync4(pluginsDir)) {
+  const manifestPlugins = await getMarketplacePluginsFromManifest(marketplace.path);
+  if (manifestPlugins.length > 0) {
+    return manifestPlugins;
+  }
+  const pluginsDir = join6(marketplace.path, "plugins");
+  if (!existsSync5(pluginsDir)) {
     return [];
   }
   try {
     const entries = await readdir3(pluginsDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => ({
       name: e.name,
-      path: join5(pluginsDir, e.name)
+      path: join6(pluginsDir, e.name)
     })).sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     return [];
@@ -20688,21 +20818,114 @@ async function resolvePluginSpec(spec, options2 = {}) {
   if (!parsed) {
     return null;
   }
-  const marketplace = await getMarketplace(parsed.marketplaceName);
+  const marketplaceName = options2.marketplaceNameOverride ?? parsed.marketplaceName;
+  const marketplace = await getMarketplace(marketplaceName);
   if (!marketplace) {
     return null;
   }
+  const manifestResult = await parseMarketplaceManifest(marketplace.path);
+  if (manifestResult.success) {
+    const pluginEntry = manifestResult.data.plugins.find((p) => p.name === parsed.plugin);
+    if (pluginEntry) {
+      const resolvedSource = typeof pluginEntry.source === "string" ? resolve4(marketplace.path, pluginEntry.source) : pluginEntry.source.url;
+      if (typeof resolvedSource === "string" && existsSync5(resolvedSource)) {
+        return {
+          path: resolvedSource,
+          marketplace: marketplaceName,
+          plugin: parsed.plugin
+        };
+      }
+    }
+  }
   const subpath = options2.subpath ?? parsed.subpath ?? "plugins";
-  const pluginPath = join5(marketplace.path, subpath, parsed.plugin);
-  if (!existsSync4(pluginPath)) {
+  const pluginPath = join6(marketplace.path, subpath, parsed.plugin);
+  if (!existsSync5(pluginPath)) {
     return null;
   }
   return {
     path: pluginPath,
-    marketplace: parsed.marketplaceName,
+    marketplace: marketplaceName,
     plugin: parsed.plugin
   };
 }
+async function resolvePluginSpecWithAutoRegister(spec) {
+  const parsed = parsePluginSpec(spec);
+  if (!parsed) {
+    return {
+      success: false,
+      error: `Invalid plugin spec format: ${spec}
+  Expected: plugin@marketplace or plugin@owner/repo[/subpath]`
+    };
+  }
+  const { plugin: pluginName, marketplaceName, owner, repo, subpath } = parsed;
+  let marketplace = await getMarketplace(marketplaceName);
+  if (!marketplace) {
+    const sourceToRegister = owner && repo ? `${owner}/${repo}` : marketplaceName;
+    const autoRegResult = await autoRegisterMarketplace(sourceToRegister);
+    if (!autoRegResult.success) {
+      return {
+        success: false,
+        error: autoRegResult.error || "Unknown error"
+      };
+    }
+    marketplace = await getMarketplace(autoRegResult.name ?? marketplaceName);
+  }
+  if (!marketplace) {
+    return {
+      success: false,
+      error: `Marketplace '${marketplaceName}' not found`
+    };
+  }
+  const expectedSubpath = subpath ?? "plugins";
+  const resolved = await resolvePluginSpec(spec, {
+    ...subpath && { subpath },
+    marketplaceNameOverride: marketplace.name
+  });
+  if (!resolved) {
+    return {
+      success: false,
+      error: `Plugin '${pluginName}' not found in marketplace '${marketplaceName}'
+  Expected at: ${marketplace.path}/${expectedSubpath}/${pluginName}/`
+    };
+  }
+  return {
+    success: true,
+    path: resolved.path,
+    pluginName: resolved.plugin,
+    ...marketplace.name !== marketplaceName && { registeredAs: marketplace.name }
+  };
+}
+async function autoRegisterMarketplace(name) {
+  const wellKnown = getWellKnownMarketplaces();
+  if (wellKnown[name]) {
+    console.log(`Auto-registering well-known marketplace: ${name}`);
+    const result = await addMarketplace(name);
+    if (!result.success) {
+      return { success: false, error: result.error || "Unknown error" };
+    }
+    return { success: true, name };
+  }
+  if (name.includes("/") && !name.includes("://")) {
+    const parts = name.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      console.log(`Auto-registering GitHub marketplace: ${name}`);
+      const result = await addMarketplace(name);
+      if (!result.success) {
+        return { success: false, error: result.error || "Unknown error" };
+      }
+      const registeredName = result.marketplace?.name ?? parts[1];
+      return { success: true, name: registeredName };
+    }
+  }
+  return {
+    success: false,
+    error: `Marketplace '${name}' not found.
+  Options:
+  1. Use fully qualified name: plugin@owner/repo
+  2. Register first: allagents plugin marketplace add <source>
+  3. Well-known marketplaces: ${Object.keys(wellKnown).join(", ")}`
+  };
+}
 function isPluginSpec(spec) {
   const atIndex = spec.lastIndexOf("@");
   if (atIndex === -1 || atIndex === 0 || atIndex === spec.length - 1) {
@@ -20715,9 +20938,9 @@ function getWellKnownMarketplaces() {
 }
 
 // src/core/sync-state.ts
-import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir4 } from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
-import { join as join6, dirname as dirname3 } from "node:path";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir4 } from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join7, dirname as dirname3 } from "node:path";
 
 // src/models/sync-state.ts
 var SyncStateSchema = exports_external.object({
@@ -20728,15 +20951,15 @@ var SyncStateSchema = exports_external.object({
 
 // src/core/sync-state.ts
 function getSyncStatePath(workspacePath) {
-  return join6(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
+  return join7(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
 }
 async function loadSyncState(workspacePath) {
   const statePath = getSyncStatePath(workspacePath);
-  if (!existsSync5(statePath)) {
+  if (!existsSync6(statePath)) {
     return null;
   }
   try {
-    const content = await readFile6(statePath, "utf-8");
+    const content = await readFile7(statePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = SyncStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -20765,19 +20988,19 @@ function getPreviouslySyncedFiles(state, client) {
 }
 
 // src/core/sync.ts
-async function selectivePurgeWorkspace(workspacePath, state, clients) {
+async function selectivePurgeWorkspace(workspacePath, state, clients, options2) {
   if (!state) {
     return [];
   }
   const result = [];
   const previousClients = Object.keys(state.files);
-  const clientsToProcess = [...new Set([...clients, ...previousClients])];
+  const clientsToProcess = options2?.partialSync ? clients : [...new Set([...clients, ...previousClients])];
   for (const client of clientsToProcess) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join7(workspacePath, filePath);
-      if (!existsSync6(fullPath)) {
+      const fullPath = join8(workspacePath, filePath);
+      if (!existsSync7(fullPath)) {
         continue;
       }
       try {
@@ -20799,8 +21022,8 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
 async function cleanupEmptyParents(workspacePath, filePath) {
   let parentPath = dirname4(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join7(workspacePath, parentPath);
-    if (!existsSync6(fullParentPath)) {
+    const fullParentPath = join8(workspacePath, parentPath);
+    if (!existsSync7(fullParentPath)) {
       parentPath = dirname4(parentPath);
       continue;
     }
@@ -20885,8 +21108,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join7(defaultSourcePath, file);
-      if (!existsSync6(fullPath)) {
+      const fullPath = join8(defaultSourcePath, file);
+      if (!existsSync7(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -20904,8 +21127,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join7(cachePath, parsed.filePath);
-        if (!existsSync6(fullPath)) {
+        const fullPath = join8(cachePath, parsed.filePath);
+        if (!existsSync7(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -20913,13 +21136,13 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         if (file.source.startsWith("/")) {
           fullPath = file.source;
         } else if (file.source.startsWith("../")) {
-          fullPath = resolve4(file.source);
+          fullPath = resolve5(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join7(defaultSourcePath, file.source);
+          fullPath = join8(defaultSourcePath, file.source);
         } else {
-          fullPath = resolve4(file.source);
+          fullPath = resolve5(file.source);
         }
-        if (!existsSync6(fullPath)) {
+        if (!existsSync7(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -20928,8 +21151,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file.dest}' - no workspace.source configured and no explicit source provided`);
         continue;
       }
-      const fullPath = join7(defaultSourcePath, file.dest ?? "");
-      if (!existsSync6(fullPath)) {
+      const fullPath = join8(defaultSourcePath, file.dest ?? "");
+      if (!existsSync7(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -20965,7 +21188,7 @@ function collectSyncedPaths(copyResults, workspacePath, clients) {
 }
 async function validatePlugin(pluginSource, workspacePath, offline) {
   if (isPluginSpec(pluginSource)) {
-    const resolved = await resolvePluginSpecWithAutoRegister(pluginSource, offline);
+    const resolved = await resolvePluginSpecWithAutoRegister(pluginSource);
     if (!resolved.success) {
       return {
         plugin: pluginSource,
@@ -20977,7 +21200,8 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
     return {
       plugin: pluginSource,
       resolved: resolved.path ?? "",
-      success: true
+      success: true,
+      ...resolved.pluginName && { pluginName: resolved.pluginName }
     };
   }
   if (isGitHubUrl(pluginSource)) {
@@ -20994,15 +21218,15 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join7(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join8(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
       success: true
     };
   }
-  const resolvedPath = resolve4(workspacePath, pluginSource);
-  if (!existsSync6(resolvedPath)) {
+  const resolvedPath = resolve5(workspacePath, pluginSource);
+  if (!existsSync7(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -21036,7 +21260,7 @@ async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryR
 async function collectAllSkills(validatedPlugins) {
   const allSkills = [];
   for (const plugin of validatedPlugins) {
-    const pluginName = await getPluginName(plugin.resolved);
+    const pluginName = plugin.pluginName ?? await getPluginName(plugin.resolved);
     const skills = await collectPluginSkills(plugin.resolved, plugin.plugin);
     for (const skill of skills) {
       allSkills.push({
@@ -21076,9 +21300,9 @@ function buildPluginSkillNameMaps(allSkills) {
 }
 async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   const { offline = false, dryRun = false, workspaceSourceBase } = options2;
-  const configDir = join7(workspacePath, CONFIG_DIR);
-  const configPath = join7(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync6(configPath)) {
+  const configDir = join8(workspacePath, CONFIG_DIR);
+  const configPath = join8(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync7(configPath)) {
     return {
       success: false,
       pluginResults: [],
@@ -21104,6 +21328,22 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
       error: error instanceof Error ? error.message : `Failed to parse ${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`
     };
   }
+  const clients = options2.clients ? config.clients.filter((c) => options2.clients?.includes(c)) : config.clients;
+  if (options2.clients) {
+    const invalidClients = options2.clients.filter((c) => !config.clients.includes(c));
+    if (invalidClients.length > 0) {
+      return {
+        success: false,
+        pluginResults: [],
+        totalCopied: 0,
+        totalFailed: 0,
+        totalSkipped: 0,
+        totalGenerated: 0,
+        error: `Client(s) not configured in workspace.yaml: ${invalidClients.join(", ")}
+  Configured clients: ${config.clients.join(", ")}`
+      };
+    }
+  }
   const validatedPlugins = await validateAllPlugins(config.plugins, workspacePath, offline);
   let validatedWorkspaceSource = null;
   if (config.workspace?.source) {
@@ -21143,18 +21383,20 @@ ${errors2}`
     };
   }
   const previousState = await loadSyncState(workspacePath);
-  const purgedPaths = previousState ? config.clients.map((client) => ({
+  const purgedPaths = previousState ? clients.map((client) => ({
     client,
     paths: getPreviouslySyncedFiles(previousState, client)
   })).filter((p) => p.paths.length > 0) : [];
   if (!dryRun) {
-    await selectivePurgeWorkspace(workspacePath, previousState, config.clients);
+    await selectivePurgeWorkspace(workspacePath, previousState, clients, {
+      partialSync: !!options2.clients
+    });
   }
   const allSkills = await collectAllSkills(validatedPlugins);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
   const pluginResults = await Promise.all(validatedPlugins.map((validatedPlugin) => {
     const skillNameMap = pluginSkillMaps.get(validatedPlugin.resolved);
-    return copyValidatedPlugin(validatedPlugin, workspacePath, config.clients, dryRun, skillNameMap);
+    return copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap);
   }));
   let workspaceFileResults = [];
   if (config.workspace) {
@@ -21162,8 +21404,8 @@ ${errors2}`
     const filesToCopy = [...config.workspace.files];
     if (sourcePath) {
       for (const agentFile of AGENT_FILES) {
-        const agentPath = join7(sourcePath, agentFile);
-        if (existsSync6(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join8(sourcePath, agentFile);
+        if (existsSync7(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -21202,11 +21444,11 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       };
     }
     workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache });
-    if (!dryRun && config.clients.includes("claude") && sourcePath) {
-      const claudePath = join7(workspacePath, "CLAUDE.md");
-      const agentsPath = join7(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync6(join7(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync6(agentsPath) && !existsSync6(claudePath)) {
+    if (!dryRun && clients.includes("claude") && sourcePath) {
+      const claudePath = join8(workspacePath, "CLAUDE.md");
+      const agentsPath = join8(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync7(join8(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync7(agentsPath) && !existsSync7(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -21252,7 +21494,14 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       ...pluginResults.flatMap((r) => r.copyResults),
       ...workspaceFileResults
     ];
-    const syncedFiles = collectSyncedPaths(allCopyResults, workspacePath, config.clients);
+    const syncedFiles = collectSyncedPaths(allCopyResults, workspacePath, clients);
+    if (options2.clients && previousState) {
+      for (const [client, files] of Object.entries(previousState.files)) {
+        if (!clients.includes(client)) {
+          syncedFiles[client] = files;
+        }
+      }
+    }
     await saveSyncState(workspacePath, syncedFiles);
   }
   return {
@@ -21265,79 +21514,6 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     purgedPaths
   };
 }
-async function resolvePluginSpecWithAutoRegister(spec, _offline = false) {
-  const parsed = parsePluginSpec(spec);
-  if (!parsed) {
-    return {
-      success: false,
-      error: `Invalid plugin spec format: ${spec}
-  Expected: plugin@marketplace or plugin@owner/repo[/subpath]`
-    };
-  }
-  const { plugin: pluginName, marketplaceName, owner, repo, subpath } = parsed;
-  let marketplace = await getMarketplace(marketplaceName);
-  if (!marketplace) {
-    const sourceToRegister = owner && repo ? `${owner}/${repo}` : marketplaceName;
-    const autoRegResult = await autoRegisterMarketplace(sourceToRegister);
-    if (!autoRegResult.success) {
-      return {
-        success: false,
-        error: autoRegResult.error || "Unknown error"
-      };
-    }
-    marketplace = await getMarketplace(autoRegResult.name ?? marketplaceName);
-  }
-  if (!marketplace) {
-    return {
-      success: false,
-      error: `Marketplace '${marketplaceName}' not found`
-    };
-  }
-  const expectedSubpath = subpath ?? "plugins";
-  const resolved = await resolvePluginSpec(spec, subpath ? { subpath } : {});
-  if (!resolved) {
-    return {
-      success: false,
-      error: `Plugin '${pluginName}' not found in marketplace '${marketplaceName}'
-  Expected at: ${marketplace.path}/${expectedSubpath}/${pluginName}/`
-    };
-  }
-  return {
-    success: true,
-    path: resolved.path
-  };
-}
-async function autoRegisterMarketplace(name) {
-  const wellKnown = getWellKnownMarketplaces();
-  if (wellKnown[name]) {
-    console.log(`Auto-registering well-known marketplace: ${name}`);
-    const result = await addMarketplace(name);
-    if (!result.success) {
-      return { success: false, error: result.error || "Unknown error" };
-    }
-    return { success: true, name };
-  }
-  if (name.includes("/") && !name.includes("://")) {
-    const parts = name.split("/");
-    if (parts.length === 2 && parts[0] && parts[1]) {
-      console.log(`Auto-registering GitHub marketplace: ${name}`);
-      const repoName = parts[1];
-      const result = await addMarketplace(name, repoName);
-      if (!result.success) {
-        return { success: false, error: result.error || "Unknown error" };
-      }
-      return { success: true, name: repoName };
-    }
-  }
-  return {
-    success: false,
-    error: `Marketplace '${name}' not found.
-  Options:
-  1. Use fully qualified name: plugin@owner/repo
-  2. Register first: allagents plugin marketplace add <source>
-  3. Well-known marketplaces: ${Object.keys(wellKnown).join(", ")}`
-  };
-}
 
 // src/core/github-fetch.ts
 async function resolveBranchAndSubpath(owner, repo, pathAfterTree) {
@@ -21465,17 +21641,17 @@ async function fetchWorkspaceFromGitHub(url) {
 
 // src/core/workspace.ts
 async function initWorkspace(targetPath = ".", options2 = {}) {
-  const absoluteTarget = resolve5(targetPath);
-  const configDir = join8(absoluteTarget, CONFIG_DIR);
-  const configPath = join8(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync7(configPath)) {
+  const absoluteTarget = resolve6(targetPath);
+  const configDir = join9(absoluteTarget, CONFIG_DIR);
+  const configPath = join9(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync8(configPath)) {
     throw new Error(`Workspace already exists: ${absoluteTarget}
   Found existing ${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`);
   }
   const currentFilePath = fileURLToPath2(import.meta.url);
   const currentFileDir = dirname5(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep}dist${sep}`);
-  const defaultTemplatePath = isProduction ? join8(currentFileDir, "templates", "default") : join8(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join9(currentFileDir, "templates", "default") : join9(currentFileDir, "..", "templates", "default");
   try {
     await mkdir5(absoluteTarget, { recursive: true });
     await mkdir5(configDir, { recursive: true });
@@ -21506,20 +21682,20 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
-        const fromPath = resolve5(options2.from);
-        if (!existsSync7(fromPath)) {
+        const fromPath = resolve6(options2.from);
+        if (!existsSync8(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
         const fromStat = await stat2(fromPath);
         let sourceYamlPath;
         if (fromStat.isDirectory()) {
-          const nestedPath = join8(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join8(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync7(nestedPath)) {
+          const nestedPath = join9(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join9(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync8(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync7(rootPath)) {
+          } else if (existsSync8(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -21535,14 +21711,14 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             sourceDir = parentDir;
           }
         }
-        workspaceYamlContent = await readFile7(sourceYamlPath, "utf-8");
+        workspaceYamlContent = await readFile8(sourceYamlPath, "utf-8");
         if (sourceDir) {
           const parsed2 = load(workspaceYamlContent);
           const workspace = parsed2?.workspace;
           if (workspace?.source) {
             const source = workspace.source;
             if (!isGitHubUrl(source) && !isAbsolute2(source)) {
-              workspace.source = resolve5(sourceDir, source);
+              workspace.source = resolve6(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
           }
@@ -21550,11 +21726,11 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join8(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync7(defaultYamlPath)) {
+      const defaultYamlPath = join9(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync8(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
-      workspaceYamlContent = await readFile7(defaultYamlPath, "utf-8");
+      workspaceYamlContent = await readFile8(defaultYamlPath, "utf-8");
     }
     await writeFile4(configPath, workspaceYamlContent, "utf-8");
     const copiedAgentFiles = [];
@@ -21566,7 +21742,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           const filePath = basePath ? `${basePath}/${agentFile}` : agentFile;
           const content = await fetchFileFromGitHub(parsedUrl.owner, parsedUrl.repo, filePath, parsedUrl.branch);
           if (content) {
-            await writeFile4(join8(absoluteTarget, agentFile), content, "utf-8");
+            await writeFile4(join9(absoluteTarget, agentFile), content, "utf-8");
             copiedAgentFiles.push(agentFile);
           }
         }
@@ -21574,27 +21750,27 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     } else {
       const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
       for (const agentFile of AGENT_FILES) {
-        const sourcePath = join8(effectiveSourceDir, agentFile);
-        if (existsSync7(sourcePath)) {
-          const content = await readFile7(sourcePath, "utf-8");
-          await writeFile4(join8(absoluteTarget, agentFile), content, "utf-8");
+        const sourcePath = join9(effectiveSourceDir, agentFile);
+        if (existsSync8(sourcePath)) {
+          const content = await readFile8(sourcePath, "utf-8");
+          await writeFile4(join9(absoluteTarget, agentFile), content, "utf-8");
           copiedAgentFiles.push(agentFile);
         }
       }
     }
     if (copiedAgentFiles.length === 0) {
-      await ensureWorkspaceRules(join8(absoluteTarget, "AGENTS.md"));
+      await ensureWorkspaceRules(join9(absoluteTarget, "AGENTS.md"));
       copiedAgentFiles.push("AGENTS.md");
     } else {
       for (const agentFile of copiedAgentFiles) {
-        await ensureWorkspaceRules(join8(absoluteTarget, agentFile));
+        await ensureWorkspaceRules(join9(absoluteTarget, agentFile));
       }
     }
     const parsed = load(workspaceYamlContent);
     const clients = parsed?.clients ?? [];
     if (clients.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-      const agentsPath = join8(absoluteTarget, "AGENTS.md");
-      const claudePath = join8(absoluteTarget, "CLAUDE.md");
+      const agentsPath = join9(absoluteTarget, "AGENTS.md");
+      const claudePath = join9(absoluteTarget, "CLAUDE.md");
       await copyFile2(agentsPath, claudePath);
     }
     console.log(`✓ Workspace created at: ${absoluteTarget}`);
@@ -21628,11 +21804,11 @@ Next steps:`);
 }
 
 // src/core/status.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join10 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
-  const configPath = join9(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync8(configPath)) {
+  const configPath = join10(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync9(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -21645,9 +21821,14 @@ async function getWorkspaceStatus(workspacePath = process.cwd()) {
     const config = await parseWorkspaceConfig(configPath);
     const plugins = [];
     for (const pluginSource of config.plugins) {
-      const parsed = parsePluginSource(pluginSource, workspacePath);
-      const status = getPluginStatus(parsed);
-      plugins.push(status);
+      if (isPluginSpec(pluginSource)) {
+        const status = await getMarketplacePluginStatus(pluginSource);
+        plugins.push(status);
+      } else {
+        const parsed = parsePluginSource(pluginSource, workspacePath);
+        const status = getPluginStatus(parsed);
+        plugins.push(status);
+      }
     }
     return {
       success: true,
@@ -21666,7 +21847,7 @@ async function getWorkspaceStatus(workspacePath = process.cwd()) {
 function getPluginStatus(parsed) {
   if (parsed.type === "github") {
     const cachePath = parsed.owner && parsed.repo ? getPluginCachePath(parsed.owner, parsed.repo) : "";
-    const available2 = cachePath ? existsSync8(cachePath) : false;
+    const available2 = cachePath ? existsSync9(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -21676,7 +21857,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync8(parsed.normalized);
+  const available = existsSync9(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -21684,14 +21865,23 @@ function getPluginStatus(parsed) {
     path: parsed.normalized
   };
 }
+async function getMarketplacePluginStatus(spec) {
+  const resolved = await resolvePluginSpecWithAutoRegister(spec);
+  return {
+    source: spec,
+    type: "marketplace",
+    available: resolved.success,
+    path: resolved.path ?? ""
+  };
+}
 
 // src/core/workspace-modify.ts
-import { readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { readFile as readFile9, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 async function addPlugin(plugin, workspacePath = process.cwd()) {
-  const configPath = join10(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync9(configPath)) {
+  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync10(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -21699,31 +21889,14 @@ async function addPlugin(plugin, workspacePath = process.cwd()) {
     };
   }
   if (isPluginSpec(plugin)) {
-    const parsed = parsePluginSpec(plugin);
-    if (!parsed) {
-      return {
-        success: false,
-        error: `Invalid plugin spec: ${plugin}`
-      };
-    }
-    const autoRegResult = await ensureMarketplaceRegistered(plugin);
-    if (!autoRegResult.success) {
-      return {
-        success: false,
-        error: autoRegResult.error || "Unknown error"
-      };
-    }
-    const resolved = await resolvePluginSpec(plugin, parsed.subpath ? { subpath: parsed.subpath } : {});
-    if (!resolved) {
-      const marketplace = await getMarketplace(autoRegResult.registeredAs || parsed.marketplaceName);
-      const expectedSubpath = parsed.subpath ?? "plugins";
+    const resolved = await resolvePluginSpecWithAutoRegister(plugin);
+    if (!resolved.success) {
       return {
         success: false,
-        error: `Plugin '${parsed.plugin}' not found in marketplace '${parsed.marketplaceName}'
-  Expected at: ${marketplace?.path ?? `~/.allagents/marketplaces/${parsed.marketplaceName}`}/${expectedSubpath}/${parsed.plugin}/`
+        error: resolved.error || "Unknown error"
       };
     }
-    return await addPluginToConfig(autoRegResult.registeredAs ? plugin.replace(/@[^@]+$/, `@${autoRegResult.registeredAs}`) : plugin, configPath, autoRegResult.registeredAs);
+    return await addPluginToConfig(resolved.registeredAs ? plugin.replace(/@[^@]+$/, `@${resolved.registeredAs}`) : plugin, configPath, resolved.registeredAs);
   }
   if (isGitHubUrl(plugin)) {
     const validation = validatePluginSource(plugin);
@@ -21741,8 +21914,8 @@ async function addPlugin(plugin, workspacePath = process.cwd()) {
       };
     }
   } else {
-    const fullPath = join10(workspacePath, plugin);
-    if (!existsSync9(fullPath) && !existsSync9(plugin)) {
+    const fullPath = join11(workspacePath, plugin);
+    if (!existsSync10(fullPath) && !existsSync10(plugin)) {
       return {
         success: false,
         error: `Plugin not found at ${plugin}`
@@ -21751,58 +21924,9 @@ async function addPlugin(plugin, workspacePath = process.cwd()) {
   }
   return await addPluginToConfig(plugin, configPath);
 }
-async function ensureMarketplaceRegistered(spec) {
-  const atIndex = spec.lastIndexOf("@");
-  const marketplaceName = spec.slice(atIndex + 1);
-  if (!marketplaceName) {
-    return {
-      success: false,
-      error: `Invalid plugin spec: ${spec}`
-    };
-  }
-  const existing = await getMarketplace(marketplaceName);
-  if (existing) {
-    return { success: true };
-  }
-  const wellKnown = getWellKnownMarketplaces();
-  if (wellKnown[marketplaceName]) {
-    console.log(`Auto-registering well-known marketplace: ${marketplaceName}`);
-    const result = await addMarketplace(marketplaceName);
-    if (!result.success) {
-      return { success: false, error: result.error || "Unknown error" };
-    }
-    return { success: true, registeredAs: marketplaceName };
-  }
-  if (marketplaceName.includes("/") && !marketplaceName.includes("://")) {
-    const parts = marketplaceName.split("/");
-    if (parts.length >= 2 && parts[0] && parts[1]) {
-      const owner = parts[0];
-      const repo = parts[1];
-      const ownerRepo = `${owner}/${repo}`;
-      const existingByRepo = await getMarketplace(repo);
-      if (existingByRepo) {
-        return { success: true, registeredAs: repo };
-      }
-      console.log(`Auto-registering GitHub marketplace: ${ownerRepo}`);
-      const result = await addMarketplace(ownerRepo, repo);
-      if (!result.success) {
-        return { success: false, error: result.error || "Unknown error" };
-      }
-      return { success: true, registeredAs: repo };
-    }
-  }
-  return {
-    success: false,
-    error: `Marketplace '${marketplaceName}' not found.
-  Options:
-  1. Use fully qualified name: plugin@owner/repo
-  2. Register first: allagents plugin marketplace add <source>
-  3. Well-known marketplaces: ${Object.keys(wellKnown).join(", ")}`
-  };
-}
 async function addPluginToConfig(plugin, configPath, autoRegistered) {
   try {
-    const content = await readFile8(configPath, "utf-8");
+    const content = await readFile9(configPath, "utf-8");
     const config = load(content);
     if (config.plugins.includes(plugin)) {
       return {
@@ -21825,8 +21949,8 @@ async function addPluginToConfig(plugin, configPath, autoRegistered) {
   }
 }
 async function removePlugin(plugin, workspacePath = process.cwd()) {
-  const configPath = join10(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync9(configPath)) {
+  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync10(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -21834,7 +21958,7 @@ async function removePlugin(plugin, workspacePath = process.cwd()) {
     };
   }
   try {
-    const content = await readFile8(configPath, "utf-8");
+    const content = await readFile9(configPath, "utf-8");
     const config = load(content);
     let index = config.plugins.indexOf(plugin);
     if (index === -1 && isPluginSpec(plugin) === false) {
@@ -21860,6 +21984,49 @@ async function removePlugin(plugin, workspacePath = process.cwd()) {
 
 // src/cli/commands/workspace.ts
 var workspaceCommand = new Command("workspace").description("Manage AI agent workspaces - initialize, sync, and configure plugins");
+async function runSyncAndPrint() {
+  console.log(`
+Syncing workspace...
+`);
+  const result = await syncWorkspace();
+  if (!result.success && result.error) {
+    console.error(`Sync error: ${result.error}`);
+    return false;
+  }
+  for (const pluginResult of result.pluginResults) {
+    const status = pluginResult.success ? "✓" : "✗";
+    console.log(`${status} Plugin: ${pluginResult.plugin}`);
+    if (pluginResult.error) {
+      console.log(`  Error: ${pluginResult.error}`);
+    }
+    const copied = pluginResult.copyResults.filter((r) => r.action === "copied").length;
+    const generated = pluginResult.copyResults.filter((r) => r.action === "generated").length;
+    const failed = pluginResult.copyResults.filter((r) => r.action === "failed").length;
+    if (copied > 0)
+      console.log(`  Copied: ${copied} files`);
+    if (generated > 0)
+      console.log(`  Generated: ${generated} files`);
+    if (failed > 0) {
+      console.log(`  Failed: ${failed} files`);
+      for (const failedResult of pluginResult.copyResults.filter((r) => r.action === "failed")) {
+        console.log(`    - ${failedResult.destination}: ${failedResult.error}`);
+      }
+    }
+  }
+  console.log(`
+Sync complete:`);
+  console.log(`  Total copied: ${result.totalCopied}`);
+  if (result.totalGenerated > 0) {
+    console.log(`  Total generated: ${result.totalGenerated}`);
+  }
+  if (result.totalFailed > 0) {
+    console.log(`  Total failed: ${result.totalFailed}`);
+  }
+  if (result.totalSkipped > 0) {
+    console.log(`  Total skipped: ${result.totalSkipped}`);
+  }
+  return result.success && result.totalFailed === 0;
+}
 workspaceCommand.command("init [path]").description("Create new workspace and sync plugins").option("--from <template>", "Copy workspace.yaml from existing template/workspace").action(async (path3, options2) => {
   try {
     const targetPath = path3 ?? ".";
@@ -21891,17 +22058,25 @@ Sync complete: ${syncResult.totalCopied} files copied`);
     throw error;
   }
 });
-workspaceCommand.command("sync").description("Sync plugins to workspace").option("--offline", "Use cached plugins without fetching latest from remote").option("-n, --dry-run", "Simulate sync without making changes").action(async (options2) => {
+workspaceCommand.command("sync").description("Sync plugins to workspace").option("--offline", "Use cached plugins without fetching latest from remote").option("-n, --dry-run", "Simulate sync without making changes").option("-c, --client <client>", "Sync only the specified client (e.g., opencode, claude)").action(async (options2) => {
   try {
     const offline = options2.offline ?? false;
     const dryRun = options2.dryRun ?? false;
     if (dryRun) {
       console.log(`Dry run mode - no changes will be made
+`);
+    }
+    if (options2.client) {
+      console.log(`Syncing client: ${options2.client}
 `);
     }
     console.log(`Syncing workspace...
 `);
-    const result = await syncWorkspace(process.cwd(), { offline, dryRun });
+    const result = await syncWorkspace(process.cwd(), {
+      offline,
+      dryRun,
+      ...options2.client && { clients: [options2.client] }
+    });
     if (!result.success && result.error) {
       console.error(`Error: ${result.error}`);
       process.exit(1);
@@ -21974,7 +22149,14 @@ workspaceCommand.command("status").description("Show sync status of plugins").ac
     } else {
       for (const plugin of result.plugins) {
         const status = plugin.available ? "✓" : "✗";
-        const typeLabel = plugin.type === "github" ? plugin.available ? "cached" : "not cached" : "local";
+        let typeLabel;
+        if (plugin.type === "marketplace") {
+          typeLabel = plugin.available ? "marketplace" : "not synced";
+        } else if (plugin.type === "github") {
+          typeLabel = plugin.available ? "cached" : "not cached";
+        } else {
+          typeLabel = "local";
+        }
         console.log(`  ${status} ${plugin.source} (${typeLabel})`);
       }
     }
@@ -21994,7 +22176,7 @@ Clients (${result.clients.length}):`);
   }
 });
 var pluginSubcommand = new Command("plugin").description("Manage plugins in .allagents/workspace.yaml");
-pluginSubcommand.command("add <plugin>").description("Add plugin to .allagents/workspace.yaml (supports plugin@marketplace, GitHub URL, or local path)").action(async (plugin) => {
+pluginSubcommand.command("install <plugin>").description("Install plugin to .allagents/workspace.yaml (supports plugin@marketplace, GitHub URL, or local path)").action(async (plugin) => {
   try {
     const result = await addPlugin(plugin);
     if (!result.success) {
@@ -22004,9 +22186,11 @@ pluginSubcommand.command("add <plugin>").description("Add plugin to .allagents/w
     if (result.autoRegistered) {
       console.log(`✓ Auto-registered marketplace: ${result.autoRegistered}`);
     }
-    console.log(`✓ Added plugin: ${plugin}`);
-    console.log(`
-Run "allagents workspace sync" to fetch and sync the plugin.`);
+    console.log(`✓ Installed plugin: ${plugin}`);
+    const syncOk = await runSyncAndPrint();
+    if (!syncOk) {
+      process.exit(1);
+    }
   } catch (error) {
     if (error instanceof Error) {
       console.error(`Error: ${error.message}`);
@@ -22015,14 +22199,18 @@ Run "allagents workspace sync" to fetch and sync the plugin.`);
     throw error;
   }
 });
-pluginSubcommand.command("remove <plugin>").description("Remove plugin from .allagents/workspace.yaml").action(async (plugin) => {
+pluginSubcommand.command("uninstall <plugin>").alias("remove").description("Uninstall plugin from .allagents/workspace.yaml").action(async (plugin) => {
   try {
     const result = await removePlugin(plugin);
     if (!result.success) {
       console.error(`Error: ${result.error}`);
       process.exit(1);
     }
-    console.log(`✓ Removed plugin: ${plugin}`);
+    console.log(`✓ Uninstalled plugin: ${plugin}`);
+    const syncOk = await runSyncAndPrint();
+    if (!syncOk) {
+      process.exit(1);
+    }
   } catch (error) {
     if (error instanceof Error) {
       console.error(`Error: ${error.message}`);
@@ -22189,9 +22377,9 @@ pluginCommand.command("validate <path>").description("Validate plugin structure
   console.log("(validation not yet implemented)");
 });
 
-// src/cli/commands/update.ts
+// src/cli/commands/self.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { dirname as dirname6, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function detectPackageManagerFromPath(scriptPath) {
   if (scriptPath.includes(".bun")) {
@@ -22205,14 +22393,15 @@ function detectPackageManager() {
 function getCurrentVersion() {
   try {
     const __dirname2 = dirname6(fileURLToPath3(import.meta.url));
-    const packageJsonPath = join11(__dirname2, "..", "package.json");
+    const packageJsonPath = join12(__dirname2, "..", "package.json");
     const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
     return packageJson.version;
   } catch {
     return "unknown";
   }
 }
-var updateCommand = new Command("update").description("Update allagents to the latest version").option("--npm", "Force update using npm").option("--bun", "Force update using bun").action(async (options2) => {
+var selfCommand = new Command("self").description("Manage the allagents installation");
+selfCommand.command("update").description("Update allagents to the latest version").option("--npm", "Force update using npm").option("--bun", "Force update using bun").action(async (options2) => {
   try {
     let packageManager;
     if (options2.npm && options2.bun) {
@@ -22262,11 +22451,11 @@ Update complete.`);
 
 // src/cli/index.ts
 var __dirname2 = dirname7(fileURLToPath4(import.meta.url));
-var packageJsonPath = join12(__dirname2, "..", "package.json");
+var packageJsonPath = join13(__dirname2, "..", "package.json");
 var packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
 var program2 = new Command;
 program2.name("allagents").description("CLI tool for managing multi-repo AI agent workspaces with plugin synchronization").version(packageJson.version);
 program2.addCommand(workspaceCommand);
 program2.addCommand(pluginCommand);
-program2.addCommand(updateCommand);
+program2.addCommand(selfCommand);
 program2.parse();

package/package.json

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